{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "1QiCFLer1FIe" }, "source": [ "**Lab 14 – Gradient boosting and ensemble learning**" ] }, { "cell_type": "markdown", "metadata": { "id": "vCyq3-8y1FIj" }, "source": [ "_This notebook contains the sample from https://github.com/ageron/handson-ml3/blob/main/07_ensemble_learning_and_random_forests.ipynb, https://github.com/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn and https://github.com/catboost/tutorials" ] }, { "cell_type": "markdown", "metadata": { "id": "9J5g6PDs1FIk" }, "source": [ "\n", " \n", " \n", "
\n", " \"Open\n", " \n", " \n", "
" ] }, { "cell_type": "code", "source": [ "!pip install scikeras[tensorflow] -qq\n", "!pip install xgboost -U -qq\n", "!pip install lightgbm -U -qq\n", "!pip install catboost -U\n", "!pip install shap" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Dpt39LbKyuet", "outputId": "d814ae5f-37c3-46a7-b68d-d9148142fd87" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Requirement already satisfied: catboost in /usr/local/lib/python3.7/dist-packages (1.0.6)\n", "Requirement already satisfied: numpy>=1.16.0 in /usr/local/lib/python3.7/dist-packages (from catboost) (1.21.6)\n", "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from catboost) (1.15.0)\n", "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from catboost) (1.4.1)\n", "Requirement already satisfied: pandas>=0.24.0 in /usr/local/lib/python3.7/dist-packages (from catboost) (1.3.5)\n", "Requirement already satisfied: graphviz in /usr/local/lib/python3.7/dist-packages (from catboost) (0.10.1)\n", "Requirement already satisfied: plotly in /usr/local/lib/python3.7/dist-packages (from catboost) (5.5.0)\n", "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from catboost) (3.2.2)\n", "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.24.0->catboost) (2.8.2)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.24.0->catboost) (2022.1)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->catboost) (1.4.2)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->catboost) (0.11.0)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->catboost) (3.0.9)\n", "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib->catboost) (4.2.0)\n", "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.7/dist-packages (from plotly->catboost) (8.0.1)\n", "Collecting shap\n", " Downloading shap-0.40.0-cp37-cp37m-manylinux2010_x86_64.whl (564 kB)\n", "\u001b[K |████████████████████████████████| 564 kB 5.0 MB/s \n", "\u001b[?25hRequirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from shap) (1.4.1)\n", "Requirement already satisfied: tqdm>4.25.0 in /usr/local/lib/python3.7/dist-packages (from shap) (4.64.0)\n", "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from shap) (1.3.5)\n", "Requirement already satisfied: numba in /usr/local/lib/python3.7/dist-packages (from shap) (0.51.2)\n", "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from shap) (1.21.6)\n", "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.7/dist-packages (from shap) (1.3.0)\n", "Collecting slicer==0.0.7\n", " Downloading slicer-0.0.7-py3-none-any.whl (14 kB)\n", "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.7/dist-packages (from shap) (1.0.2)\n", "Requirement already satisfied: packaging>20.9 in /usr/local/lib/python3.7/dist-packages (from shap) (21.3)\n", "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>20.9->shap) (3.0.9)\n", "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from numba->shap) (57.4.0)\n", "Requirement already satisfied: llvmlite<0.35,>=0.34.0.dev0 in /usr/local/lib/python3.7/dist-packages (from numba->shap) (0.34.0)\n", "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas->shap) (2.8.2)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->shap) (2022.1)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas->shap) (1.15.0)\n", "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->shap) (3.1.0)\n", "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->shap) (1.1.0)\n", "Installing collected packages: slicer, shap\n", "Successfully installed shap-0.40.0 slicer-0.0.7\n" ] } ] }, { "cell_type": "code", "source": [ "import numpy as np\n", "import pandas as pd\n", "import time\n", "\n", "import tensorflow as tf\n", "#tf.compat.v1.disable_v2_behavior() #Should be enabled when using DeepSHAP, see https://github.com/slundberg/shap/issues/2189\n", "from tensorflow import keras\n", "from scikeras.wrappers import KerasClassifier, KerasRegressor\n", "\n", "from sklearn.datasets import make_moons\n", "from sklearn.ensemble import RandomForestClassifier, VotingClassifier\n", "from sklearn.ensemble import StackingClassifier\n", "from sklearn.ensemble import BaggingClassifier, GradientBoostingRegressor, GradientBoostingClassifier\n", "from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.model_selection import cross_val_score\n", "from sklearn.model_selection import GridSearchCV, RandomizedSearchCV, StratifiedKFold\n", "from sklearn.svm import SVC\n", "from sklearn.metrics import accuracy_score\n", "from sklearn.ensemble import AdaBoostClassifier\n", "from sklearn import datasets\n", "from sklearn.metrics import mean_absolute_error\n", "from sklearn.preprocessing import LabelEncoder\n", "\n", "from xgboost import XGBClassifier\n", "from xgboost import XGBRegressor\n", "\n", "import lightgbm as lgb\n", "\n", "from catboost import CatBoostClassifier, CatBoostRegressor, Pool\n", "\n", "import shap\n", "shap.initjs() \n", "\n", "import matplotlib as mpl\n", "from matplotlib import pyplot as plt\n", "from matplotlib import cm\n", "%matplotlib inline" ], "metadata": { "id": "5bV_HvPiH-9i", "colab": { "base_uri": "https://localhost:8080/", "height": 43 }, "outputId": "71539579-11a7-4ce4-d6d2-ca247872f37c" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "
" ] }, "metadata": {} } ] }, { "cell_type": "code", "source": [ "def plot_dataset(X, y):\n", " plt.plot(X[:, 0][y==0], X[:, 1][y==0], \"bs\")\n", " plt.plot(X[:, 0][y==1], X[:, 1][y==1], \"g^\")\n", " #plt.axis(axes)\n", " plt.grid(True, which='both')\n", " plt.xlabel(\"$x_1$\")\n", " plt.ylabel(\"$x_2$\", rotation=0)\n", "\n", "def plot_decision_boundary(clf, X, y, alpha=1.0):\n", " axes=[-1.5, 2.4, -1, 1.5]\n", " x1, x2 = np.meshgrid(np.linspace(axes[0], axes[1], 100),\n", " np.linspace(axes[2], axes[3], 100))\n", " X_new = np.c_[x1.ravel(), x2.ravel()]\n", " y_pred = clf.predict(X_new).reshape(x1.shape)\n", " \n", " plt.contourf(x1, x2, y_pred, alpha=0.3 * alpha, cmap='Wistia')\n", " plt.contour(x1, x2, y_pred, cmap=\"Greys\", alpha=0.8 * alpha)\n", " colors = [\"#78785c\", \"#c47b27\"]\n", " markers = (\"o\", \"^\")\n", " for idx in (0, 1):\n", " plt.plot(X[:, 0][y == idx], X[:, 1][y == idx],\n", " color=colors[idx], marker=markers[idx], linestyle=\"none\")\n", " plt.axis(axes)\n", " plt.xlabel(r\"$x_1$\")\n", " plt.ylabel(r\"$x_2$\", rotation=0)" ], "metadata": { "id": "ruWWKAR_Mz5P" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "## Voting classifier" ], "metadata": { "id": "LTrx75jqLcLg" } }, { "cell_type": "markdown", "source": [ "`Scikit-Learn` provides a `VotingClassifier` class that’s quite easy to use: just give it a list of name/predictor pairs, and use it like a normal classifier, that’s it! Let’s try it on the moons dataset (this is a toy dataset for binary classification in which the data points are shaped as two interleaving crescent moons). We will load and split the moons dataset into a training set and a test set, then we’ll create and train a voting classifier composed of three diverse classifiers:" ], "metadata": { "id": "PvL__u5fL5Sw" } }, { "cell_type": "code", "source": [ "X, y = make_moons(n_samples=500, noise=0.30, random_state=42)\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)\n", "plot_dataset(X, y)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 281 }, "id": "-AB6jsQHLfpk", "outputId": "f4b4489f-8b3b-4f2e-942a-49641835aa4a" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "Here we use [`SciKeras`](https://github.com/adriangb/scikeras) to wrap kerase model into `Scikit-Learn`." ], "metadata": { "id": "qmJ0_x9ezBAO" } }, { "cell_type": "code", "source": [ "def get_model():\n", " model= keras.models.Sequential([keras.layers.Dense(30,activation='relu',input_shape=[2]),\n", " keras.layers.Dense(20,activation='relu'),\n", " keras.layers.Dense(1,activation='sigmoid')\n", " ])\n", " model.compile(optimizer='NAdam',loss='binary_crossentropy',metrics=['accuracy'])\n", " return model" ], "metadata": { "id": "DSARLteqwsY-" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "dense_model = KerasClassifier(model=get_model, epochs=200, verbose=False)" ], "metadata": { "id": "mufRkMoGxOuu" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "voting_clf = VotingClassifier(\n", " estimators=[\n", " ('lr', LogisticRegression(random_state=42)),\n", " ('rf', RandomForestClassifier(random_state=42)),\n", " ('svc', SVC(random_state=42)),\n", " ('dense', dense_model)\n", " ]\n", ")\n", "voting_clf.fit(X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "z2-c2OA5M4aG", "outputId": "133a4343-5ec0-45d7-e7f3-7b8330d9a83d" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "VotingClassifier(estimators=[('lr', LogisticRegression(random_state=42)),\n", " ('rf', RandomForestClassifier(random_state=42)),\n", " ('svc', SVC(random_state=42)),\n", " ('dense',\n", " KerasClassifier(epochs=200, model=, verbose=False))])" ] }, "metadata": {}, "execution_count": 109 } ] }, { "cell_type": "markdown", "source": [ "When you fit a `VotingClassifier`, it clones every estimator and fits the clones. The original estimators are available via the `estimators` attribute, while the fitted clones are available via the `estimators_` attribute. If you prefer a dict rather than a list, you can use `named_estimators` or `named_estimators_` instead. For example, let’s look at each fitted classifier’s accuracy on the test set:" ], "metadata": { "id": "HMfYwrvVNeH3" } }, { "cell_type": "code", "source": [ "for name, clf in voting_clf.named_estimators_.items():\n", " print(name, \"=\", clf.score(X_test, y_test))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1Y1o7PFQNIPg", "outputId": "7853f87b-55f2-4ab1-8482-33fbef160914" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "lr = 0.864\n", "rf = 0.896\n", "svc = 0.896\n", "dense = 0.896\n" ] } ] }, { "cell_type": "markdown", "source": [ "When you call the voting classifier’s `predict()` method, it performs hard voting. For example, the voting classifier predicts class 1 for the first instance of the test set, because 3 out of 4 classifiers predict that class:" ], "metadata": { "id": "pcfc8mtjNywf" } }, { "cell_type": "code", "source": [ "voting_clf.predict(X_test[:1]), [clf.predict(X_test[:1]) for clf in voting_clf.estimators_]" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "2TrG5WLoNvGl", "outputId": "26dedde2-204a-469f-d971-b87ad8dc555d" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "(array([1]), [array([1]), array([1]), array([0]), array([1])])" ] }, "metadata": {}, "execution_count": 111 } ] }, { "cell_type": "markdown", "source": [ "Now let’s look at the performance of the voting classifier on the test set:" ], "metadata": { "id": "FfwmQiZiN-7P" } }, { "cell_type": "code", "source": [ "voting_clf.score(X_test, y_test)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "R-4gZYXnN3Q0", "outputId": "c64c50e5-7c31-4e8b-d8c3-6ca1e6fb6021" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0.88" ] }, "metadata": {}, "execution_count": 112 } ] }, { "cell_type": "code", "source": [ "plot_decision_boundary(voting_clf, X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 285 }, "id": "vQznlFPfU6aY", "outputId": "0fe2bafe-b182-4970-83fc-4ed8decdaf39" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "If all classifiers are able to estimate class probabilities (i.e., they all have a `predict_proba()` method), then you can tell `Scikit-Learn` to predict the class with the **highest class probability, averaged over all the individual classifiers.** This is called **soft voting**. It often achieves higher performance than hard voting because it gives more weight to highly confident votes. All you need to do is set the voting classifier’s voting hyperparameter to \"soft\", and ensure that all classifiers can estimate class probabilities. \n", "\n", "This is not the case for the SVC class by default, so you need to set its probability hyperparameter to True (this will make the SVC class use cross-validation to estimate class probabilities, slowing down training, and it will add a `predict_proba()` method). Let’s try that:" ], "metadata": { "id": "0OCmMXDAOEsI" } }, { "cell_type": "code", "source": [ "voting_clf.voting = \"soft\"\n", "voting_clf.named_estimators[\"svc\"].probability = True\n", "voting_clf.fit(X_train, y_train)\n", "voting_clf.score(X_test, y_test)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "tex4mcrIOBQ2", "outputId": "5dde7cd6-8849-41c6-e165-5a21e7e2aa00" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0.912" ] }, "metadata": {}, "execution_count": 114 } ] }, { "cell_type": "markdown", "source": [ "We reach 91.2% accuracy simply by using soft voting, not bad!" ], "metadata": { "id": "I__SqQ0lOdco" } }, { "cell_type": "markdown", "source": [ "For stacking neural ntwork model, you can refer to https://ensemble-pytorch.readthedocs.io/en/latest/ for more details." ], "metadata": { "id": "R7wMvsUO8t9V" } }, { "cell_type": "markdown", "source": [ "## Stacking" ], "metadata": { "id": "PBHcV002qZ1u" } }, { "cell_type": "markdown", "source": [ "`Scikit-Learn` provides two classes for stacking ensembles: `StackingClassifier` and `StackingRegressor`. For example, you can replace the `VotingClassifier` you used on the moons dataset with a `StackingClassifier`:" ], "metadata": { "id": "DP5DoUCdqbaN" } }, { "cell_type": "code", "source": [ "stacking_clf = StackingClassifier(\n", " estimators=[\n", " ('lr', LogisticRegression(random_state=42)),\n", " ('rf', RandomForestClassifier(random_state=42)),\n", " ('svc', SVC(probability=True, random_state=42))\n", " ],\n", " final_estimator=RandomForestClassifier(random_state=43),\n", " cv=5 # number of cross-validation folds\n", ")\n", "stacking_clf.fit(X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1rqpE6FZqlN1", "outputId": "6de014a5-d7c7-4bac-d60b-6c42c6644494" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "StackingClassifier(cv=5,\n", " estimators=[('lr', LogisticRegression(random_state=42)),\n", " ('rf', RandomForestClassifier(random_state=42)),\n", " ('svc', SVC(probability=True, random_state=42))],\n", " final_estimator=RandomForestClassifier(random_state=43))" ] }, "metadata": {}, "execution_count": 34 } ] }, { "cell_type": "markdown", "source": [ "For each predictor, the stacking classifier will call `predict_proba()` if available, or it will fallback to `decision_function()` if available, or as a last resort it will call `predict()`. If you don’t provide a final estimator, `StackingClassifier` will use `LogisticRegression`, and `StackingRegressor` will use `RidgeCV`." ], "metadata": { "id": "08TA3D47qsWN" } }, { "cell_type": "code", "source": [ "stacking_clf.score(X_test, y_test)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7ms6ZeGCq4_W", "outputId": "6147afb3-260d-491c-d36c-dbe82cd0c620" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0.928" ] }, "metadata": {}, "execution_count": 35 } ] }, { "cell_type": "markdown", "source": [ "You get 92.8% accuracy! which is a bit better than the voting classifier using soft voting, which got 92%." ], "metadata": { "id": "pIeOuOsOq_N-" } }, { "cell_type": "markdown", "source": [ "## Baaging and Pasting" ], "metadata": { "id": "I97bOx8CTlf3" } }, { "cell_type": "markdown", "source": [ "`Scikit-Learn` offers a simple API for both bagging and pasting with the `BaggingClassifier` class (or `BaggingRegressor` for regression). The following code trains an ensemble of 500 **Decision Tree classifiers**:⁠ each is trained on 100 training instances randomly sampled from the training set with replacement (this is an example of bagging, but if you want to use pasting instead, just set `bootstrap=False`). The `n_jobs` parameter tells `Scikit-Learn` the number of CPU cores to use for training and predictions, and –1 tells `Scikit-Learn` to use all available cores." ], "metadata": { "id": "QzERUKToTov_" } }, { "cell_type": "code", "source": [ "bag_clf = BaggingClassifier(DecisionTreeClassifier(), n_estimators=500,\n", " max_samples=100, random_state=42)\n", "bag_clf.fit(X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "x43B6MDAObRX", "outputId": "5e4c6379-1a36-497d-a99f-f949e3e1c8fa" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "BaggingClassifier(base_estimator=DecisionTreeClassifier(), max_samples=100,\n", " n_estimators=500, random_state=42)" ] }, "metadata": {}, "execution_count": 13 } ] }, { "cell_type": "markdown", "source": [ "Notice that the `BaggingClassifier` automatically performs **soft voting** instead of hard voting if the base classifier can estimate class probabilities (i.e., if it has a `predict_proba()` method), which is the case with Decision Tree classifiers." ], "metadata": { "id": "BF7-HM3KT99Q" } }, { "cell_type": "markdown", "source": [ "We compares the decision boundary of a single Decision Tree with the decision boundary of a bagging ensemble of 500 trees (from the preceding code), both trained on the moons dataset. As you can see, the ensemble’s predictions will likely generalize much better than the single Decision Tree’s predictions: the ensemble has a comparable bias but a smaller variance (it makes roughly the same number of errors on the training set, but the decision boundary is less irregular)." ], "metadata": { "id": "4lhj-r7nUMn3" } }, { "cell_type": "code", "source": [ "tree_clf = DecisionTreeClassifier(random_state=42)\n", "tree_clf.fit(X_train, y_train)\n", "\n", "fig, axes = plt.subplots(ncols=2, figsize=(10, 4), sharey=True)\n", "plt.sca(axes[0])\n", "plot_decision_boundary(tree_clf, X_train, y_train)\n", "plt.title(\"Decision Tree\")\n", "plt.sca(axes[1])\n", "plot_decision_boundary(bag_clf, X_train, y_train)\n", "plt.title(\"Decision Trees with Bagging\")\n", "plt.ylabel(\"\")\n", "plt.show()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 297 }, "id": "8wOuoYCmUMG2", "outputId": "cb3cf50f-611e-477e-cf95-6c10cd6c1df5" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmUAAAEYCAYAAAAd24GlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeZhU1Zn/P6eWXmm62cFmkX1xaVDUoEZFJIqKGBNNZkwmJmbPTPKLiZlMnGyTZCaJM5qZyWQzmkWjJiiCqK0CCoiKCkID0rKD2GwNdFfvXdv5/VELtdx7695bt5buPp/n4aGr7nbu9q33vOc97yuklCgUCoVCoVAoCour0A1QKBQKhUKhUCijTKFQKBQKhaIoUEaZQqFQKBQKRRGgjDKFQqFQKBSKIkAZZQqFQqFQKBRFgDLKFAqFQqFQKIoAZZQpCoYQol4I8SkT63UIISblo00KhaIwKD2wjhDiN0KI7xos/4EQ4pF8tsku6r5GECpPmcIIIcRBYBQQBELATuDPwO+klOECNi0rhBAdCR8rgF4i5wfwBSnlX/LfKoWiuFF6ULwIIa4CHpFSjk347gfAFCnlJ0zuQwJdgAR6gFXAl6SUrY43WKGJ8pQpzLBYSlkFTAB+Cvwz8GBhm5QdUspBsX/Ae0TOMfZdXICFEJ7CtVKhKEqUHvRv6qLXYRIwBPhBYZszsFBGmcI0UkqflPJp4GPAp4QQ5wIIIUqFEP8phHhPCHE86lIvj20nhFgihNgqhGgTQuwTQlwX/X6tEOKz0b+nCCHWCSF8QoiTQoi/JmwvhRBTon9XCyH+LIRoFkIcEkL8qxDCFV12hxBiQ7QtLUKIA0KIRVbOUQhxlRDifSHEPwshjgF/EEK4hBDfjrb9lBDib0KIoQnbfEAI8ZoQolUI0RDtsSoU/RqlB9b1INqm/UKI9mh7btc4ZpkQolsIMTz6+R4hRFAIMTj6+UdCiF9E//6jEOLHQohKoB44KzoM2CGEOCu6y5LoNWoXQrwjhJhr5tyllG3A08CshLZ9WgjRGN3XfiHEF1La/i0hxFEhxBEhxGdT7tUwIcTK6H1/K9ruDQnbJq77RyHE/wkhno0e6w0hxOSEdT8khNgVfT5+FX1WPmvmvIodZZQpLCOlfBN4H/hg9KufAtOA2cAUoBb4HoAQ4mIiwxt3AzXAFcBBjd3+CHiRSM9sLPC/Oof/X6CaSC/uSuAfgE8nLL8E2AUMB34OPCiEEBZPcTQwlIgn4PPAPwE3R493FtAC/F/0/GqBZ4EfR7f5JvCkEGKExWMqFH0SpQfm9CBqOP0PsCjqabwU2Jp6MCllD/BWdP9E/z8EXJbweV3KNp3AIuBIgofvSHTxTcDjRK7308AvzZy0EGJI9Dw3Jnx9ArgRGEzkOt8vhLgguv51wF3ANUTu+1Upu/w/oJPI9fxU9J8RHwd+SOQZ2Av8JHqc4cATwL8Aw4jc30vNnFOfQEqp/ql/uv+ICOY1Gt9vBO4BBJEXbXLCsnnAgejfvwXu19n3WuCz0b//DPwOGKuxniTykrsBPzArYdkXgLXRv+8A9iYsq4huO9rsORIREj9QlrC8EViQ8HkMEAA8RIZuHk7Z3wvApwp979Q/9c/pf0oP7OsBUAm0Ah8ByjO04UdEDDgPcAz4GhFjtwzoBoZF1/sj8OOEtr6fsp8fAKsTPs8Cug2OK4G2aDtDwLtArcH6y4GvRf9+CPiPhGVTUu5VAJiesPzHwIbU+5pwXr9PWHY98G70738AXk9YJoDDsWenr/9TnjKFXWqB08AIImK3OequbwWej34PMA7YZ2J/3yLycr0ZdbF/RmOd4YCXSK8xxqFoW2Ici/0hpeyK/jnIxPETaZaR3mqMCcBTCefXSESwRkWX3RpbFl1+ORGhVigGCkoPMuiBjHizPgZ8ETgaHZqboXPMdUSMrAuA7UQC7q8EPkDE0Dxlof3HEv7uAsqEcWzcBVLKGiIG4K+BV4QQZQBCiEVCiI1CiNPRc7ueyH2AiNfwcMJ+Ev8eQcTA1Ftupt2x+5Z0HBmxzN7PsK8+gzLKFJYRQlxERPg2ACeJ9NzOkVLWRP9Vy0igKERensk6u4ojpTwmpfyclPIsIr3dX8XiCxI4SaS3NSHhu/FAU3ZnlN6clM+HiQw51CT8K5NSNkWXPZyyrFJK+VOH26RQFCVKD8zrgZTyBSnlQiKdtneBB3SO+RowHfgwsE5KuTN6bteTMnRp0M6skFIGgN8DE4FzhRClwJPAfwKjoobbc0SMZ4CjRIaaY4xL+LuZyIxdveVWSDpOdDh6rP7qfQtllClMI4QYLIS4kUh8wiNSyu0yMg3+ASKxBSOj69UKIa6NbvYg8GkhxIJogGytVu9QCHGrECL2YrUQEZikKfZSyhDwN+AnQogqIcQEIjEMuc7D85voMSdE2zpCCLEkuuwRYLEQ4lohhDsapHtVwrkoFP0SpQfW9EAIMUpEJjlUEkm50ZF6Tgnn1gVsBr7CGSPsNSJeNj2j7DgwTAhR7cRJCiHcROLGuoH9QAlQStTAEpFJEx9K2ORvRO7tTCFEBRDPnxa9V8uAHwghKqL3/B9sNu1Z4DwhxM1Rj99XiMSp9QuUUaYww0ohRDuRXuA9wH0kB9P+M5FAzI1CiDZgNZFeHjISBPxp4H7AR0RQEnu2MS4C3hCRfEFPE4lT2K+x3j8RiVnZT6Rn/iiRWIZc8t/RNr0YvQ4biQQQI6U8DCwBvkNErA4TCWJW75aiv6L0wJ4euIgYjUeIDPVeCXzJ4DjriAzPvpnwuQpYr7WylPJd4DFgf3To9Cyt9UzQEL3uLURi4T4spTwtpWwHvkrE+GoB/p7IdYgdv55IHNzLRO9/dFFv9P9/JDIp4xjwcLStsWWmkVKeBG4lMnHjFJE4uU129lWMqOSxCoVCoVAoHEUIMRPYAZRKKYMay39GZNJFxioOGY7jIhJTdruU8uVs9lUMqN68QqFQKBSKrBFCfFhE8tQNAX4GrIwZZEKIGUKI80WEi4E7gadsHudaIURNNM7tO0Ti2jZm2KxPkFejTAjxkBDihBBih87yq0QkGdzW6L/v5bN9CoVCoVAobPMFIrnM9hGZkZo4PFtFJK6sE/gr8F/ACpvHmRc9xklgMXCzlLLb5r6KirwOXwohriAS3PhnKeW5GsuvAr4ppbwxb41SKBQKhUKhKALy6imTUq4nEuCoUCgUCoVCoUigGGPK5olIvbB6IcQ5hW6MQqFQKBQKRT4otor3bwMTpJQdQojriZRwmJq6khDi80RqkFFZWX7h9Bln57WRivzQ1dVDe1sHoVAIt9tN1eBBVFSUAXD82ElCoVDaNm63m1Gjh6d9P3AQhIIeWlpaaDndQkVZCWNHD828WR9j8469J6WUfba+qNKw/o+RfoHSsMwIggE3p0+30NrayuDKMsaMqCl0oxzBSL/ynhJDCHE28IxWTJnGugeBudG8JJpcOHeWfP3NvzjWPkVx0LC1kZXLVxEInJlJ7fV6WHzzQupmz8y4fODixndqJEuXPskTS5dywfSx3PvNjxW6UY7jmnrTZinl3EK3wwmUhvU/zOiT0rBMlHDqeBWPP/4Ey596igWXzOC7X7ip0I1yBCP9KqrhSyHE6GjJBKJTZl1EksMpBhhrVm1IEiuAQCDImlUbAKibPZPFNy+kuqYKgOqaKiVmCoWiKMikX6A0TKFNXocvhRCPESmyOlwI8T7wfSIZi5FS/gb4KPAlIUSQSGmHj0uV3bbP0LC1kTWrNuBrbae6pooFCy+3LTC+1vaM39fNnqkETKFQOEK+9QuUhinSyatRJqX8uwzLfwn8Mk/N6fM4KSJOtGX5k88TDkdsaF9rO8uffB7AVpuqa6o0hS3Wq1QoFH0bpV8KRTpFNXypME8sHiH24vta21m5fBUNWxsL0p76Z16KC1qMcFhS/8xLtva3YOHleL3JfQav18OChZfbbqNCoSgOlH4pFNooo6yPYiZmIZ90d2vXgtX7PhMq3kKh6L8o/VIotCm2lBgKk5iNWejLqHgLhaJ/ovRLodBGGWV9lGKLWSivKKO7q0fze0Vmiim+RqHINUq/+h9Kw5xBDV/2UYotZmHRDfNxu5MfJ7fbxaIb5hekPX2JYouvUShyjdKv/oXSMOdQRlkfpdhiFupmz2TJLdcmtWfJLdeqnpIJii2+RqHINUq/+hdKw5xDDV/2YYotZqHY2tNXGAjxNQpFKsWmF8XWnr6E0jDnUEaZIi+oeAN9ii2+RqFQJKP0yxilYc6hjDKHGUgvr9lzTa3x5mttZ9nSeuqffZlFN8zPeH36+zVdsPByzRp4KqeRohD09/ctRrb6tWxpvenr09+vqdIw51BGmYNovbwrl68C7GWFLmasnKtWvAFAd1dPxuszEK5p7Dz6s2gr+gYD4X0DZ/Qr03Z2jtVXURrmHMooi+JET8Yo2LG/PZxWztUoriDT9Rko11TFsyiywSlPzEB535zSL6Pt7ByrL6M0zBmUUYZzPZm+EOzolHhbOVe9eINM+7J6HIViIOKkJ6bY37di1C+j/Vk9lkKhUmLg3HRevaDGYgl2dDKXjJVz1cpJZGZfVo+jUAxEnExHUMzvW7Hql9H+rB5LoVBGGc71ZIotIWIqToq3lXON5SQqLy9NW5bp+hT7NVUoCo2Tnphift8KrV96RpTSMIWTqOFLnJvOW+zBjk6Kt9VzjcUbWB1+KPZrqlAUGifTERTz+1YM+gXWh1CL+Zoqig9llOHsdN5iDnZ0OpeMnXPN1zYKxUDB6XQExfq+FYN+2d2uWK+povhQw5cUX8mPXKHc6ApF/0Ppl9IvRf9BecqiDISejHKjKxT9E6VfCkX/QBllA4y+Lt79PTO2QqHQR+mXor+jjLJ+QrG/7E60byBkxlYoBiJKv4rnXBWFRcWU9QOczN+TC5xqn5NT4hUKRXGg9Evpl+IMyijrBxT7y+5U+1RmbIWi/6H0S+mX4gxq+LIfUOwvu1Pt05sSL4Tg+/fcV5TDHgqFwhilX0q/FGdQnrJ+QLGX8dDK5A/W26dX7kRKCRTfsIdCociM0i+lX4ozKE9ZP8Dp5JGQObDVbOBrw9ZG/P5A2vcul8jYPq1jLL55Yfw7IURc0GLEhhVUb1Oh6BsUQr+srKP0S5FPlKesH+B08shMga1ay5ctrWflitVp+1qzagOhUDjt+9KyUsP26bUB4K67P8cPf3JXmqDFKJZhD4VCkZl861dsnRXLXkhaZ8WyF9K8VEq/FPlGecr6CU7m7zEKbK2bPVNzOcCmN7cxfkJtUjv0BKa7qyerNoDzZVcUCkVhyKd+AdQ/+3KasRUKhal/9mWlX4qCooyyPkiuc/pkCmw16smlut7tCo+Z4NpcDHsoFIrcUmj9An2jKvV7pV+KfKOMsgKQjSjlIwGhnhCVV5QZLo+1JxEt4QHw9/pp2Nqo22YzYqjKrigU+aev6pcQwlBztFD6pcg3yijLM9mKkhm3eLYsWHg5K5a9kObe7+3ppWFrI1OnTWTTm9s0t03tQSYOFyT2Qru7ew3P22wvsq+XXVEo+hJ9Rb+0DCkpZbytXq9HMwQjdXak0i9FvlGB/nkm20SE+cjpUzd7JiUl3rTvw2HJmlUb2LP7gO62Wq53vf0ZnbfTwb8KhSJ7+op+Lb55IUKItGWxtno8bs1ttb5X+qXIJ8pTlmeyEaWGrY2a06jB+eDQ7u5eze8ztTMmOqlDHHbOW/UiFYriIlujqryiTDOey2n9qps9k2VL6zWXGbU1pntKvxSFQnnK8ozdRImxYQMtgywXwaGx+DGt7zOdg9Z0cD3UTCOFou+QTaLXhq2N9Pakd/bcbpfj+mWUgLW6psrwPJR+KQqJ8pTlGbszbvTSUAghTLnFLQfn6uTQQcqM56DX1lTUTCOFom+RzYzBNas2EA6n60pJideUR8mKhhkNp8baqnceSr8UhUR5yvKM3VgDvd6alNKUQZYpmWIqesOX3d29Gc/BTM9SxVj0b/xdbeyo/xX+rrZCN0XhINnESunm/NLRmkSsapiZYUW981D6pYDCaVhePWVCiIeAG4ETUspzNZYL4L+B64Eu4A4p5dv5bGM+sBNrYBTXcN+9D2TsNVqd8ZRpSrfRORhte9fdn4t/btjayH33PqCmg/dDDjespu34QQ43rGbyvFsK3RyFg9iNlcomVYVVDTObksLqton6BbnPuaYoHIXSsHx7yv4IXGewfBEwNfrv88Cv89CmPoFeMVuw32s06hHqHW/qtIm22prq6rfjvVP0DfxdbZzY+xYgad67SXnLFIBxQe5M775VDcu1foHSsP5MITUsr0aZlHI9cNpglSXAn2WEjUCNEGJMflpX3KS621Mxmp5tJzi3bvZM6ubMSvu+YcvOjKJjZogj26n1iuLlcMPqeEyilOHIZ8WAx0yqCj2saliu9QuUhvVnCqlhxRboXwscTvj8fvS7o4krCSE+T8STxvjxo/PWuEITc7d//577NJf7Wts1hwHsBudq5SMzm+gx0xBHrvIVFXo4odDHLzSxHqYMhwCQ4RDNezcxru4aSioGF7h1xcNA1jCjVBV6w5h2NCyX+hVrr5XvzVBo/Sj08YuBQmtYsRllppBS/g74HcCFc2fpTBPsvxjFl2llmbZbziPbnGpGx8tFMV4nS7jYEad8lJApdhJ7mDFiPU0VW3aGgaxhVvUr8bOVdzKX+mV0HnY1TOlXcVBoDSs2o6wJGJfweWz0O0UCemVEQL8naCc4Vy9RrdbwQyJaL/eypfUsW1ofF4hcFON1qoSLXXHKRwmZYqf9xKF4DzOGDIdoP3GoQC1SFBt29Ausa1gu9atu9kzHNUzpV3FQaA0rNqPsaeAfhRCPA5cAPinl0QzbZEVfdNfG2mcnY7UVtATN6PsYRnl+YgKx+OaFLL55YdbXPvH+6WH1etgVp3yUkCl2Zi/5eqGbMKBQ+qVPLvULnCkorvSr+Ci0huU7JcZjwFXAcCHE+8D3AS+AlPI3wHNE0mHsJZIS49O5bE+27tpCCGLiMXNdcsmuez7TSxwTiLvu/lxW1yv1/ulh9XrYFSez16sv/pAqig+lX8bkWr9inju710zpl0KLvBplUsq/y7BcAl/JU3OyctcWYvw99Zi5Lrlk1z1vFDMSw4nel5nM23auh1UxN+rt6qUCGehxG4rsUfpljNKv9O+1UPpVXBTb8GVeycZda0cQs+1hGJVaklI63mux6543ihmJ4URv2EzPz871sCLmRr3d8vJSEIJlS+tZs2qDbgmXgRi3ocgepV/GKP3KTr+qa6qYOm0ia1ZtiMfT+f0BpV85ZkAbZdnMnrEqiE70MIxKLf3wJ3eZ2odV7LjnU8UwFad6w1Yyb1vBipjr/dCUV5QRDATT7rdRrIpCYQWlX5lR+mVPv2LbpN5zPZR+OceANsqymT1jVRCd8JBkU6Yk3ySKYa5iEKzePyvtMCvmemLU3dWT9l0gEMx5HE1/w9/Vxu51jzDtyk+oPGcp9Bf9gsyl4vJNMeqXlbZkq1++1nbThdlB6ZcedvRrQBtl2cyesfpCOTGzRc+tHitTAsU5rp9NMGym/YK5+5erWAgz8SeJSCnxej2OpgLpz6gamvr0F/2K7adYNawY9Atyo2FGxrnZe6v0Sx87+tXvjDKrvRq7L5zVF8qJRIOxfT/1xPNp3pZsxvXzOZvG6WOZvX+5iuXS+3HzeNx0d/emrR87ZzV7KTOp9ecGSlWAXHh0tbaDwuiX3rCg3fdxIOgX5EbDjIxzvftUXl5KSWmJ0q8M2NWvfmWU5XtmiJUXyujhtyrCTub3sXrNshGlQs7ccToHT+J1KC8vxeP10N3VE78mgO79zlXPu7+hVX+uv3vL8vmOOKVfsXZbGVYzKhVnhYGiX7HjWfneiEz6FTsfrXu+6MarlX6ZwK5+9SujrFhntsVegMSYIr0fbzMvupleq1nxsXLN7IhSprxEZu6PE71TJ0uipF6H7u5evF4Pt9y6KK1dyiNmj0LXnysUxahhRvpVN3umLV1wSsMGin6BcxpmVr+yGR4f6GSjX/3KKHPaG+IEWrl5Ej0m9937gGURzuR1q3/25aRA85j4vHeoiT27DyS9YFaumdUfDDN5ifSOlbiP5U8+Tzgs4+suf/J5wFrv1MmSKGavg/KI2afQ9ecKRbFpWCb9AnuGpFMa1hf0S6tk03uHmli85Brd7bRwSsOsXAelYfbIRr/6lVGWiyLX2aL3AtQ/+7JheQ2jF12vBwPp7ubEY256c1vS/lcuX4UQac8OoF0fzmpbzc7eMapFV//MS3GDLEY4LKl/5iVTYpHkpq8oi8d6ZdPrK7Yfzv5IoevPFYpi0zC7+gX50TA9ikW/9Pax6c1tjJ9QWxANU/qVe7LRr35llOWiyHW2GKVM0EqbECOTCGv1YLS8bkYYrZvaK2zY2qi7rl5bzb7kRrXotILljb5PJM1N39WjO8xohWx/OFWZkswUuv5coSg2DbOrX5AfDdNDS1PKK8o021xeUaa5Dyf0y2gfdiovOKFhThj+SsOMyUa/XA62o+DUzZ7J4psXxh+u6poqFt+8sKAPi50erl0RttvTKcXPPFcjpQTi36W2e82qDbrb67XV7Lnnygtg5KbPhgULL8frTe7PmL1nMZGN3auYx9LI6FUMHIpNw+y+m/nUMDP6BWgPCRh874R+GS0zc6650LBs9AuUhuWafuUpg+IbA586bWKSyz0TuQgEzcRUcYShdDBVNLFDno3b7Up7Qc0MRSArCAVrgIg7f8E1C1m54mnDnm8mMbDauzXTZkdmXNocRijGQG5FcVFMGmZVvyD/GpaqXxBpdypWve5myi1l0q8FCy/XnS2fi8oLRjg1DKo0LLf0O6Msn5hx4e7ZfcD0/rItr6EnIuXlpYRCYfz+QNo2pfgZJ04iBIzjJHtkLa6SQWnnkcnlHQ5Vs7vRx65dDXF3/oTx47lx8S289FJ9/BpNnTYxbbKB0Yu86Ib5rFj2AqFQOP6d2+1i0Q3zM16PnM64tDmMoOI5FMVCsekX6GuYXuyrln714tVst1U90Ip7s6pfdbNn8t6hpjTDNleVF/RwchhUaVhuUUaZTcxOr85FVuStr79J84sP8ZZ/ImU1Q9NyX2kJrV5eoKniSMrnJnZ0n522nlGsSzg4jIYtTfz5zw+ze/eeuHqeVXsWt99+O1/96nfxlB4zdW6ppJ6TEIJQKBx33xsJSiFmXGai2AK5FQOTQupXw9ZG1r+whqkdDewZVMcV1y6IH1NPw/S8TZr6Jc/WbLcdPXDCa7l4yTWMn1CbpGGJQ5D50DAnvVuF0DCjuL3+hjLKbGL2Idd7gO1mRW7Y2si++kcZJ30RAWr1JompnohotSPWy3SLyAPvFpJxnORY1bS07Y0Mvk5fOe++u4s9u/cQ7Glnwqgq3m/u4MCBA7zzzjucd95Mho0qAfwZz08LrUSGZnIMOZlnx6neYbEFcisGJoXUr5XLVzE9uJehooPR7btZuTziBU80zPTy/SWip197ZC1lNUPTjl3IvFuF1jAnvVv50DAp3XS1D2Ht2rWsW7eeQMDPuFFDHNt/MaOMMpuYfcj1HmC7WZHXv7CGi+SJZHd9IPNMHq12THMfhdQOiIBLR2rHWOgZfFJKwuEwEsnkMVU88O9f5Se/W8mLr+9ESulIL8duT8+p+ByneodmRFbNbFLkmkLp15pVG3AFuhjnShhyDNTa0q/p7mO4NMY1p7uPMmXhTZr7KWS8XiE1zEnvViYNy1a/pPTS0lzDsmXLWbFiBW2+Vm6afwGfXHyZ5bb2RZRRZhOzD7nTvbPR7btjcfSAsbs+UzsmuAT4kgXNjaSsuxkoLuPAbk/PqXNwsndoJLKFLuWiGBgUSr98re2cqzXk2Oo13E6rHeNdgC+ctJ5bSMZXR9YvJv2CwmqY094tPQ1zRL/Cw9m3by9vvvkGvtZWRg4dxLc+vQiXq18li9BFGWU2sfKQO9U787e3MM51Cjfm3PXZtKPYjAM7PT0nzyFfQx92so4nt+kKzh430tE2peLvamP3ukeYduUn+nXJo/5MIfQLYPjgEsZ1mAuZyKYdxaZfUFgN6zv6dTnn13mYPmMi8+dfzalTpznRfIJ//tnv+ck3P0OJN3uTpdj1SxllNilEfMKRtctwuwQkdw4N3fV2sfJy7dy5mf37X+PCC0cTDobYstd81nWzvUA7PT2np27nY+jDSm9aW7Bf4Jprcis0hxtW03b8YL8vedSfKVR81aUjewh0pnxpEDJhF6s1MbMpUm5220JrWN/Qr5jBOYsP3/IhampqeOyxx3j1nQM8tGw9X/zY1Vm3sdj1a0AZZU67s/Mdn9B5eA+klG5IdNc7idmXq2FrIy+8sJpgMIAQArfXw/INmxAis6vZSi/Qzo9ILqZu53pIxEpvWk+wN2yop6Zmhq3jZ+pFxgrtghwQBcKLib6uXwBl3ScJox8y4RRW9MuuJ8rqtgNBw5zQr5jBWVZ5mosvnsP+/fs4eqSJ5taOjMfvD/o1YIyyYnRnW+WcL/80b8cy+3KtWbWBYDA5/1kgFEKIMKFwmNOnW2hr66KsfETavla/8AfNl3L1CxuZPDG9WO/0KbXU1c0BYVzexeo56JEqXlOnTaRhy86cPkNWetN6wtze3kpNjb3jZ+pFJhbaHQgFwouF/qBfkD8Ns6Jfdj1Rdra1aghno2FaxhdYnwFqBSf0KxuDsz/o14AxylQWYmuYfbn0XiApJF5XmHXr1tHT0824sePS1ultO8481z7eDk+hlzOBvm1tLTz8p0fT1i8rL+eKKy5j4pRBuNyZe03ZBLc2bG1k+ZPPx4uh+1rbNTObO/0MWelN6wl2VZU9iyxTLzK2PFZoV4ZDRdvb7G/oFgZ/5iWlXxpkq19mDIOe1lOa+uVkElW7GqalX8uffJ7S0pKc/g46oV928531F/0aMEaZykJsHY/XE3+By8tLNafB671YNZUV/Pp7n+Er//YgG17RrtP2pSs9DHUll0cB6O4O8Nhjj6Wt73K7OXDgAJ/61CeYPLUaXD7D9mcTN1P/zEtxQcuEr7Wd799zn2NDAWZ703qCffnli9ixw3wm9hiZepGJy2MUa2+zv6GnU47CT70AACAASURBVN3dvTRsbVSGmQbZ6JcZw+CcsmaG+tP1y8kkqnY1TEu/wmGpW1LK19rOffc+UBT6ZXdGaH/RrwFjlAkhNPNlCSE01i5O8jXFO3WoBCAYDGmuu2Dh5Tz91OqkIUyv283CuedRWV6Cy+0G0retKgkzwXMqrTxKKBRm//6TmscKhUIEAn6CwRASgZk7ZzduRk+8jMj3kJK2YF/B2eMusGyUmelFtp84FF8eQ4ZDtJ8wP7FDYQ+jmpB9ydufDw2zql92DAN/ewtnhU5Ain7lIhG0HQ3ru/pl73noT/o1YIwyvQSmTiQ2LYTQ5PIFsjLUWzd7Jr1dQ3jhhScJBHoIB0PceuUlVHhK+cy//pZBNVVceMloXC6JEF7KykZSUlLD5J7XcQf3EJtKOlU08Q5TGTRoJJdeep5mu8pKS7lq/hVMnVGFcLXqtr+Q+YnyPSSeLthufKes78dML3L2kq9n0VJFNhiVGsrW21+ozl6uNMyqfsW2sZII9cjaZZF6nETqck4VTRyuPs+Ra5fr++FN8CCmUnj9skd/0q8BY5SZcVPbeRmKUWiyxepQ76xZF7Jnz1EeffRRJgwRzJkygZ8++AyDqgcxY8YohIi5lAMEAie46tLZeF55FBk1yNxCMtHbxtWf/gaeymG67XK7XXjZx64/3kXvOdfz0itb0+6VU/ejvKKM7q70CQUlJV7KK8oMfwj74pB4X+lFDlTqZs+k/tmXNZ/JbDSsWDt72WBVv6wmQpXd7QS3rEOGIt+7kEws8XHzF2/FayKe09/ewr6//Y+mhoEzgfh6+lVeUcaiG+Zrlq2KofSrsAwYo0zPTT112kTuu/eBtAfR7MugG4D77MsFFZpscCIAMxSSTJw0jNTR4WAwwPFXf0dtarI1GaJ96284e/FnDPd7cOVf6Di0i/cOteALjQeS75VTwr/ohvmsWPYCodCZdrrdLm5cck18P1rPDUTiV/oafaUXOZBZdMN8xzVM73156onnDbezQ740zKkAcr1rc2j1X6lNHWGRYZrWLsuoXxDJN6mnYR4NL5aT+rXohvlxI1RPv4QQfS5OsT/p18CoW0BEXBbfvDD+YlbXVFE3ZxYNW3bqikLsZTBCNwC3q4eGrY3ZNToBPUFxMqg0xoKFl+NNyZxsJ1aitFTb5q/0t8Z7mTFkKEjn4d2G+/O3t3ByyzpAUitPUMqZOLbYvXJK+Otmz2TJLdcmPS9Lbrk2SagWLLwclys9ss3vDzh67xUKyI2G6c6elpKVy1f1SQ1zSr/0ro1d/YLMGqbl3TJqix5m9Sv1OkFu7r11BIGeGrZva+Ttt7fg9/upHlRewPbkjwHjKYN0N/V99z6gO7YeI9PLkK8AXKdnqhjhVABmb2+QsrL0mnavhM8BIu1ffPNC0/s9snZZUtxA6qynWFudmmadKd5Bb0gpFAr3qeBrRd/BaQ0z0i+nhxbzpWFO6ZfetYnpFzivYUZtsYoZ/QJ46onn02KrC5kuSkoXXe0jWPXiBh5//HGONDVRN2kId95yRd7bUggGlFGWipneR6aXIZcBuInUzZ7Je4ea2PzWdqSUCCGomzMrZy+NEwGYhw62MH3GKEB7MoWVsiczJ4/mZEIcR2Ldz1iOoNi6VoU/m8DabHq2xVYwWdH3yFbDtN4Xq/s3Sz41zAn9ynRtwHkNKy8vJRgM2cpLZkdL6mbPtP37lTP9Co9i+7ZdPPPMMxw90sTCeefwvS/dhMftzn7ffYABbZQZ9RLB+GVIfCCFSJv4Ed+/UzRsbaRhy854j0ZKScOWnYyfUFu0P+QnT3Yyt2oc4KO9XTunmNmyJ8EJfs2LHOtpxu6V1V5ytoHOdj1z/SVDu6Kw2NWwRP0qryjTNTwGsoalaokeTmrYohuvTjpmPiZrFLJQuhZSuunp6aG3t4cyr+Abd1w3YAwyGOBGmVFPyOhlSH0gtQwyK5njzbyAVgPYC+2FESKSV6yzU3L77V9ixYrf0NaWnsZi8OAaOlrPin9e/cJDmufpO/AuVSR/7xaSobRzuWcP1Vf+PyafPZ+OVph89llM/tyCpHU7dDJo6B3PrOve7pCMqjChcAI7GpaqX91dPbjdLqSUSQlHnfbQ5KtIuJMketz0AuPNlm7yHXyXKpmuYWM5xbGqaVxx7YL4sayca7ZaUuhC6ckIerrDnD59mq6uLgBcfSiXqBMMaKPMbuyB1gMJZxLU5iKdhpUA9kJ6YcrdIXbU/4obLr2a1a9tY/269XR39zB8eDXgI3koUyBlNX/601/i32gZbgDrQrNSvhFUVY1nRugdRvY2cuK1v/HWtiOW26t3PF9rO1J6EMI4XsfuM9SfpqMrCoed509Lv0KhMOUVZZSUeHPmoTH7zBfaixxLWTHltq8lpbjItnTTumCyhnm9HhZN8OM5+DaLZ1Vwts1zy1ZL7DxDudAvKT20tw7lmZX1PPnkkzQ3N/OhOaOpqiyzvc++yIA2ysBe7IHRjKUf/uQuICIssZ6V3kNupbdhxcVcSC9M3TAfbce7GFWzk9/+4E6++MPf89qrrwIwclQVkyYNp6zMQ09PkP37T3Li+K6k7T8wbyLl5emTA9KRtDU3MrSsEeGGIV07+fWLh2n3W5tQrHc8j6eU9pZqBg9tJbUigVYv/q67P2fpuE7XfVMMXKxqmNGM8W/f8+X450waZlVn8lEk3AmOrF1Gx3u70lJcmDVeMg0px3AFuggc2I4byckt66i96hZTec5SsTv8mI2GOa9fbtpbqlm58kUee+wx2tpauf2GS/nyx+bb3F/fJa9GmRDiOuC/ATfweynlT1OW3wHcCzRFv/qllPL3+WyjGTI9kGZ7elZ6G1ZczPnwwiS+1IMHD6GiYjSDvCGmDu4EoHnvJkaMugAhzpRZOnG8nRPHtduQaLDFgoAzcW75CaJ5aXEB10zq5al3rU2b3r//JDNmjMLtPmPMhUJhRo6cGB2WTm6HU734fM6mVSgSMZtIO9NzblVn8lEk3ApGwfhIbUPJKNFsPEavvBS325WUI0yLqeJIJPZFYCnPWSpWtcQJDcuFfkkZCXmRUiKAslJvnyqD6BR5M8pE5Nf5/4CFwPvAW0KIp6WUO1NW/auU8h/z1S47ZHogzfb0rPQ2NHtp11xB3XmXIUPJD251dQ0+X/qwXHV1DTI0wsKZarOtYQsrn15NIBDJsdPW1kJ7u48PTeqMrxMOh3j68QfoDVZx8SWXMHbsWN399fa20NXVhN4sTS1K8TNenCRmS3ncMG9ciJKZiwi4KiydT29vCz09xwmHA7hcXsaOncFHb/07Bg/1QUocm1O9eKem7SsUVjHzg2rmObfqLcnW0+T0pIOMwfgmDaW0GL3uXlwuoZtVHyL6NU6cxB2rdhIK2vaWWdUSJzTMef0KMXhoG4tvuhYpJU899RQPLVvPiVNtfOdzN9rcZ98kn56yi4G9Usr9AEKIx4ElQKpRVvSkPpDlFWUgJcuW1ltKYKoXpOtrbee+ex8wrsF2zVWMGXUBG9bvIhRO7pHV1p5De/tGwgllJ1wuN7W157B+bfaX+9VXn40bZDFKZA+zqtvxxOxDGWbOKD+vNVdw/vnnMW7c+KT1hd9HaeOf6J15B69t3o+WQVZaWglAb29n2rKpIj1+zCVgdtVh/FNus3VesTZVzbmdwdUCIQJp61iN7TMSrVivO7besqX11D/7MkhJd3dvvzPU/F1t7F73CNOu/ES8SLAi/2j9oE6dNjH+DBoNvyV+n41+3XLrIt3nOh9eZC3D5MxwYkRPMxlKsdiz9SeHpe0rHJaUlHj59j1f1pwgoKVfMhyy7S2LaUk8Hm7yGN11rcT25VO/hAgwuBrOOWcWb7/9NqdPn2bTtkZCoeuTRjIKRb70K59GWS1wOOHz+8AlGut9RAhxBbAb+LqU8rDGOgUn8YFM7XHpkdrTM5pynehShvR6aCueqsfteott2/cSCiXHPAEMHuxl1KgyvF5BICA5fryL7dufs3eyKcyaNTjNrTxVHCHV0exxCy4eepzHHnucysrKpGULzzrO7GE+dj37n/TUTNV0U/f0dPD++93U1panZc4fIjrjvcwYQoZo2b+JP77QbOu8Ym16e+mPON11D/Mum4W39ETSOmZ78WaHCLRmwsXob2kyDjespu34waQiwUYoIy53JA7D2dWwbPTL6LnOhxdZ6xyThhNjGHjLYrFno0PDOcnZusfQMjK19ItwyFRVACP04uEScWr4Wmu9bPQr0DuSja/t5OGH/8KuXe8yZmg5v/zXO4rCIIP86VexBfqvBB6TUvYKIb4A/Am4OnUlIcTngc8DjB8/Or8tTEFvJqYWWj29mDhq9aYSS6Skz5YK0t19hObjRxhUln4bT3bASeuTEU0R8FdQUpocHK8lMi4kF0+qYP1RP/6OMy/rIG+Y84b4cAk4b4iPo73dyNL0IceAP8jJI8cI9VZy1riheEsi5ymESMqqDZFJFlvfPBD9dMryOSW2aXLZMd5+8xWmTJlE7fhyJN3x9cz24s0OEWR6fvpLmgx/Vxsn9r4FSJr3bmJc3TUZhcqqCPYl+ouG2dWvTM+1E8lfjdAyTLQ0TK98UrxckpSMc51iT+hMAtjEY4C28ZqqXzF++OW77J1QSpuMPHxODV/rrZdpGy0E5TQf7+Gttzaze/cuJo6s5Df/9gWqKoujtFI+9SufRlkTMC7h81jOBPQDIKVM/DX9PfBzrR1JKX8H/A7gwrmzzAci5QArwadOTzH2egVDBpXw9K++ZboNqdix5rfsPcTyDZsIJHjoNorzufnyucyZMiFt/StvT/687/VlnNjzJjIcosTr5qZawXPH3En787rd3PqhS5jz5eT9/fzxZ2jt7Eo7xpBBldT/7tum2q9FYptcwLjerYRCnyS1PKzZXrzZ+2nm+XEqwLmQnqfDDavjsTpShjMKlR0R7Ev0Nw2zo19OPNd66SsyoWWYbHTXmS6ZlFguye0STOco20JnQjRSjRw7+c6sklTCycDDZ0bD8q9fLsLhcCTQPxzm6ssu0DTICqVh+dSvfPoF3wKmCiEmCiFKgI8DTyeuIIRIHAi/CSj6qs5mX6RM6xkV69VbFggYz+4xQ6I1b5Y5UyZw8+VzqamMeLdqKit0DbJUYg+rjMa7yXAI2byLJRfPNLW/hXPPw5uS3dnrdrNw7nmm25+pTR43jA7tI9TVorl+3eyZ3HX35/jhT+7irrs/pzv9X4vU7808P04FONu5106gdc+b927C39Wmu42WCCpygxMaZke/nHiuE4frrFA3O724u1mDLOaRihclD4cY7zrF8MElpvblVMF0ozbF4uEC7dp5GDNpWDHqFxRGw/KtX3nzlEkpg0KIfwReIJIS4yEp5TtCiH8DNkkpnwa+KoS4iciUt9PAHflqn1lSgx+nTptIw5adhi7c2AuXOm0aIeju6tHdT2y79w41senNbUn7dLncHDvWkdW5ZGPNz5kywZQRlkriwxpDyjDVvnf51sczu3hjx1y1aTutnV3UVFawcO55ttpi1CaBpGPr43DOF23tc+q0iWn3TEt4M9XXcyrAuZCeJ717rtfb1BPB/uYtKxROaVhismwj/QJYseyFpBQRbrcr6+fa7HCdHnaHSFOLikOkgsniWRWcvThz4oBcxMxptSnbNBvLn3w+qcKDyyUKpl9QOA3Lt37lNaZMSvkc8FzKd99L+PtfgH/J9ji5KtGhFfzYsGUndXNmsWf3gSSRS/wceyhTp03H0NtPbLuGLekzJsPhEKNHl9PVUco//cdf0pabYe7gw0yqCOIWEAgGePQPv2Jz27jMG2bBtcPfZag3eWKCDIdo3LGFX6zt1tzGUyooHeRGuECGobcjRLA38pK04+OhAxuADY62yUWYQLM9R22sxl8qWsWX9WbyOj370qr73UnaTxyKC1QMGQ7RfuJQ0nexoYnSQUMtiWB/I5clhpzUsFgNSyP9ik2Gkin3MxQKU//MS4D9SSxmh+ucpvPwnjNesih6sWegfz+djJmz2iYzRCZfyZTPyeRLv6BwGmZWvyCiYQ0rf5GVfhVboH/W5LJEh17w457dBwyzITdsbeSpJ55PEyYz+7nv3gd0eyElJW6mzRjN/n2nOXVK26DRY5A3xEcvPIU7+p65BUwsO8VT77jpCOSu+OvO/UMMlh5P+2bYsHImThqCK9pQ4YaSQS6aTrRYPmezbRo6bBi33XYb1153JZKjlvenF/y6Z/eBpM9W0gRkQ6E9T7OXfN3UerGhCU/rcdMi2N/IdYkhOxqW+JzqYbSPNas2JHlcYnR397L8yecB6+emN1xnNyu+Fc758k8zrxQlXyWjrLTJDGtWbUhLfhsKhZOC9vOlX1BYDTOrXxDRsEB3+ntiRb/6nVHmVHJPrd6NnWDW2EtpZJAZ7SdTkKTLJZgxs5apU6y5iIcffx532ykSSwi53W6+uHAsJ0dea2lfuWTP3g0Eg8kJGN1ul+45+3xHOdG8j2CwB4+njJEjJlNdrZ+zR4sxZ43hA/POpbTiKFYS2sbbYOI5yWd9P6vu90KQODQRDgaYe9t3B+RQZS71q272TMsalvqcGmFHH8NhSf0zL1l+5p0erssVdu5nMRRjz3Qv812ftG9pGLjcXi74yLdtaVi/M8qcKNGh98CVl5cmDTvGMApktDLdXGs/ZuqoBYM93HLrIlPHiLHrwaX0tKUO2YUYVdbGFRb3lUt+8iPtAEmtc96xfTPPPruOYDAQX+fEyd1cdEkd5553oeljejw9uDzpXjswJ5hm8gDls76fFfd7oSjk8GoxkUv9AuvZ8rPVL6NjxtDS1EzkYrguF2RrBDtt7Jg1+DI9J/muTzqQNKzfGWVOlOjQe+A8Xg9er8dSpmmzYqq3n0yBlBA5t5KyJlMvnJSl+H1BPGUV1H1jKd5BQzX2mJ7J3mn87afY/+SPmfzR71JSVQkun+Z6RvezpCwho4qsZO3LzxFMqTQQDARYu3YlF1yknwtKSg+Eh3Ama6QbGRqZtl5qeamIYK6G8GDOr5sTX2/BgutZ+fSypKoHXq+XBQuuj+/XSKy1jm2eaM29aKfySHML3QsX454oOGdKLYMqyrLYd2bsTFn3d7VxYo8K7Ifc6teaVRssZ8vPVr/AnIaBWYNB4PdJXKXVuvol03NpO06ifmlrqARXiyNGsFPGjhWDL9Nz4kTnAYBwNVKWAh7CYV9SFZpErAwhZosdDes41cTxXRuJCW82GtbvjDInSnToPVjdXRHvjBXXsp53DYjXRjPaT+w7o5i02KyoTC+cDFVy6ECQplX/jffodt569Bf4p9yq2/ZcUrJ3abwNFXM/yznnjaOkLD0Tv5n7GQoMZVfjSc16nxC7n8lBqzGkLKX5iJd3dzVqVkZI5PXXV6aVlwoEAjz7zEpOn0p8lTxMmXIR+/dvpbe3i9LSCiZNms3pUx7WvrQdgNLSCnp70/OtlZZWxNexSzAQpHJQBeXlZexvauYb9z4GwIiaCv7nO59iwlnDs9q/EXYSJh5uWJ3eCx6g3rJc6pevtd3yzD8j/UqcfWm0jzMaVp824ggRHTSlX9JDu28YO//6fVxNxaNfWm1wuVzMmDGRBdfMZ+WK57I2gp3I6WbF4Mv0nDjRefD3jGDnjvdpaYno9q5du9mw4VWEkEwam32NZrvY0bA96x8j9ffFrob1O6PMienGMbHR+t7yrBmdKvflFWV8+54vm9pF7Hhavc25F58fz6ht9MLJYA3v7DjNE488yIfKXkO4JKLpNf6wuonOoPXHoNITZMmEY6w4NNry9pWeIF+ceSjehr9sOs2Hp3dz/qf+i6pRARIf7kz3M1Kao5HHHnuc6uoQJSXpkxS83nI620ZROfgEkBC8Gh7Eof0BHn30L2zZskW3lxbjnHNqdMpBdfLLX/7SYMsWNm9OypNMdbWX2trKpPJR4bBk794TbN5stK/MCOHiwropfPjmJTTu2gtI2ts72PnOO9z53d9x7923M2eG/RQietidst52PL32abENTeSL3OrXmWOY3p8D+hU7Jminxlh0w3x9g+HF16iri1Tjaz4qeXrpn5jVvAF3EenXH1ZH3u3E/blcLs4/v46///uPs/gmN2vWrM7oAUSW57QYu1WDz+g5ya7z4KK7YyRrVr/GsmVPxTvT7e0dBPzdfO0T1zH/4sJUMLGjYf6uNrp96eEudjWs3xllkH2JDj2PlJlg/VQSa4GZ+V6PTGJt/MIJOjoq2bJlDSPa3kCURc5DIJk37CgvHLT+ws87u52xlb2mtx/kDXPz1Dae2jOYeaM6EZxpwwcH78LbHubAi7/j/E98DUTyUKbe/RSUc6rZz+bNb9PYuJMxoyqYPGUUroRaaaFQGL/fTdP7zUyfWY0UZxLC+nuHsHPnK7y9eTOnT51gcIU37RiJBPyD0spLRb4PEurW9tLpcbobwv4uxowdgrfEQ8Af5Oj7LbSeTi++bpWObj8bN/m5ffoF3HnnHZSVeejs7GXp0mWsffllfvmn5Tz4H1/L+jip2I2pGDxqEj1tJ5HhEMLlZuTUiwechyyR3OlXZAjLyr6d0i8w1rBlS+s1t/H5fGzf2kI4HOa55+oZdGg5YlRx6de8YZEZ2on783UHeOmll/D5fHzyk3/P17/+LYRHOxm1lG46fcM5evQ0V151PfXPPpmTYuxOGnx2Ow9SevCdHsrKp59j2bJlnDp1ksHlbjxuF0MrPNz1lY9x2ZypltvjFHY07HDDaoTL7Zh+mTLKhBAvA/8upVwlhPgxUC2l/CfbRy1yjDxlVnH6RdB76I2PI5BhCb0+5ozoxBO1WTwuuLg2zBe/+iVL497+rjY2P/kfyJD57fe9vozjuzbyk9smcvJgQzzuw+OCMYPCCAFde1bx7/96nLKaYSxYeCV1s88h4kEJaMabzJ59YVJpjmsuOp+L50yKJ5at9sKE7u28Hb6EcDiMlK6kYsNSQigUIhQOMayqlOX/d7fhOWiVl9IrB1VIPnn3/TR3Ra7pmLOGUzn4GF3to5k+fRpvvLERv8nAbSvYnbJe6HQd/RGjwHqrsUlOe270NEzvOMEg3H//LwiHw7QcO8g/X9KNJ+oMLxb9uuis2LMLc0YHaBkxFm95Fe82NvHWW2/S3t7ONdfM473D22nztSYZMFKWcOr4IJ566im2bt3K1VfP59prP8Irr9TT4zvJRSUHGXHtnY4EzzsxNJ6I1c6DlGUcb/KwdOnj1NfX09XRzj/cdBlfvPUqW7+tTmNHi3KhX2bLLH0fuEcIcTswB/h/to7WR3DSU5aLkhp2jzPCtzFtNMJOCRurJSSSXML7tyDDOuWhZJipoglfaxvPL3ua1//zGxx8p5NNG4+ycvmquGjH4k0atu5I28WcKRP41sdv5N/vvI0PDu1kbKWfc0r3ax5ux45NbNv2IuedN5Qp59SyZa+xqzmb8lJ9HX9XGzvqf6VbWsRoyroRdrdT6OPExKPEfRVKv8Jhye5dR3lv/27eP7iXG6Z04/UkhycUg37JcBAZDsYaxFTRREd3D9Mn1/DNy3ro8R1k+/ZXaIsO08X1a8t+Dh9w8Yc/PMzf/vY3tm/bRn19PaHgIL7+je/x9x8YQU24jZpm7RjThq2N3HfvA3z/nvu4794HaNhqnOw6m9JSTuDvGsHGjVt46aWX6Olq5zufX8yXbpufF4Msk36BPS3KhX6Z8pRJKdeLyJW7C7hKShkSQtwM3AAMBh6UUr5ouxVFRjG4eXNxnAr/sbiXLIbVcW87PYOkB1emG2QiIYHtOE6yR9YyKdyE29fM6498l70l4wkG0+NNVq96mY9/bLZuOzm1C5eAiSVHCXe3AmdmSTVsbeS5Z1cTDAYQQlBS6mH5hk0AhkaW3fJSfR2j4Fd/VxvN+zbbmrLeF6a69zXqZs+k/pmXLKfv0dsX5F+/SkoqOHDgJJ2+Tpb+IjLUfuSV39PVkpzMuRj0KxG3kHENmxhuYlRZD9dN8fNuit0RCAR5/rk1+Hyv88bGjSADlHoFvb299Pp78bedNiwhZTd1htOVBKwQCkl6e3sIBgKcPaqSG66oy9uxMwXv29WwXOiX2eHL84AxwCkpZTuAlHI5sFwIMQT4T6DfGGX5dPNmmyjQyvb7Rt/O3/76V86dNJpffPvvbZ1LtnXA4ExivcMNqzmx582Uh1oyQ7zHWaIFIWCC6z2GhE7yNtPoJTmey9eqnUYj3s6EuA//zifhwjPDk2tWbYjnM4sRCIVYtWn7gDS6jMgU/Hq4YTXhYIBR0+dZjqXI51T3gcSiG692TMPyrV+zZn6INS++SkPDQ7iEYOTQyLM2csldltueipP6VVIxmD2vPE7zvs1p28U1DJjsPUVTeDTtVCSt09nZzmuvbaW6XPCjr32Cu+89Uy7vyPo/GZaQyneeMKfJ53ClmeB9uxqWC/3KOHwphBgD/AVYAnQIIa5LWeVfgf9zvGUFJF9u3lhvJ31YzlzNxWy3t4PVnoGRCGrtyy1gZEKgv9sFQ0UXU0Xy7EWA6ppqzWPGX8Jor9YtJIGD6wi0n46vE7tmpfiZ52qkNJqbrbUzPU2FHbbsPcTPH3+G7zz4N37++DMZh0aLGaPhnlTBMxoeUOSPfGhYrvRrx/ZNjrUxFSf1C6Dl/fRzdQuZpGEAc1z70tbr6QkwfkQ5f/rpV5gyftSZBb0+TjU8l1ZCKtB+ZjKRnn45kToDrA+NFjOZhquLTcMMPWVCiApgGfANKWWjEOJHwM+A56PDmT8F6qWUb+e+qfklF27e1F6h3x/IqrdTiN6S1Z6BkQjOWnhnNOD2zDmEJHgI4xaRlyiWMWIczeyRtXFvmdfr4ZqF8zWPqSWkoWCA5/77m5x902eomz0zniNuqjjCUDqYKprYIc/GLVz88rHs4pm6Ar34Ap3xJA+tnV08se4NVr22gwpvqal9jBw6mFuuuRCPO3d1SM3g72rj+J43QWe4tWsTOwAAIABJREFUJ/Fah8MhGlb+grrF/08F6RcBTmtYvvTr5ZeeY9bMBY61OxEn9cvf1UYo6E9aFpKCDeFZXO7aGdcwIaBK9lBFV9xbFgqFOXr4FBedP4O/Pv8GnV29RDKFCLyHXkjTr2AgwHO/+DFnL77TUL+cSJ2RjxJKvg4/gUAwLY7QacwMVydpWCjAwc3PMe2DH89pu4wwvCJSyi5gXsLn9Qmf/wm4BqgWQkyRUv4mZ63sB2g96HqY7e3kMtFgtsSyIs9aeKfuD/S+19Pr1wlAiPQJFS4Bs0pOssU/JmGY5Fya3kvfr7YHTlIZOM3K5at471ATvT29lOJnnDiJiMay7QqNoeHdFl46oV2qZcTIQUyaNIzSUg+9vUH27z9F84mOtPUu+cAEysqSh1olcKy9lTc2JvfI9fYZlmFefnUT//Uvd1JRbs6QywWHG1bHDbIYsd7muLprkod2ZJhAdzuHNj/H1AKKmsJ58qpfPu3UEfnG39WGp6RUtw6rpn6JiFdMa3Sujr28Is+jpyfI/v0naW7u4PCRM/4Mt9tDbW0tpd3vEA4lh1a4haTS32KoX/tcYzMOT5sZbrbS2bcyfF1aFmbMmDGMGDmCvXv28sXv/4b7v3MngweVG7Y5GzINV2sNT5/c9zZnX3h9wTqWts1UKeX/AP/jYFv6NU7UkNNaL1eJBrPFTFZkLePJpRNqIICxopkbvv09vFXG5xfrDf/o4eV0+5N7soSDbH5rO1JKpoojSYumu49Rc+USzX329Jymvf0wsTi1sjIvs2aNoeqScZSVJZdZaW7eqrmPsjIvH731o6b22dj4Hlv37OHOe37FAz/+Uk7LIxmVFWk7lj5zNeYp0BI8gOb9W5hQQFFTOE9e9at6iKW25YpMGqapX0iqPUFkKN1Yq3b1UjtkBgFXBePHQ2rC5NLSMi6/fB7TZ1Xjcrdx370PpF8fI/1yHTX0ZJn1gJnt7Fv1qLlLjvCBS2cixKd5+OFHaNz1Lp+559f8/kdfoGZwpW67M2GkX5mGq7U1TBbUW9Yvk8cWI07UkEvF6QkJTmE2K7LRUMK+15elTQKQ4RBNa5/k7MV3mGpHmkEW24+U8V5mbIghMmuqmYW3LsJTOSxtm9/+9sekl2mSdHQc5oorLmPWrAsT1j1IW1t6MtnBg2u4445PZNynEG189rN38tBDf2DPrka27T7MpbNzl1DR6Mdn8OhJdPtORNspGDX9A/F1tq64P03wIqcwMEsk9WfyqV/zr76e40etFyl3EjMaZlW/wsLFOWUH6J38UcrKSpk6dQoVFWXENMDlElRUtYKIxDTpXXM9/RoTOk6gvTVplmYieh6w+mdfTjKizHb27YTPeEs6GT9+LJMnT+bAgQOcaO3k+Om2rIwyI/2aveTr8RxzWhqmZbQBtBwuXAydMspyTMy9q0d5eSklpSW2Zi9Zma7e2LiZw4c3cdHFtchwJBA9V7MM7WZ2T0TzZQkH6Ty8y/Q+yktKNA0zIQRTOaLxPbS+/eukWU4xtIwsiAjkiy8upbSiNX7dr7l2nuaPzTXXzmPfwTXx+6VHW1srQ4YMoSY2kcFifrwKT4h/mH4KdzB9aDUVox+fWKHwM4aj5Piu1xk97QNUDjsr/qN0JhnnmfNVCWD7B4XQr1kz53L86Ktp62/ZeyieGLqmsoKFc88rWg3TDKEgzIl9b/Kb5QepqhrMDTfcwE1LFlE99DRCpHsh9YwjI/1KnaWZiFFN58RKD0ad/cThSj30loVDg9m7q4OHH/4Lr732Om6C/PirtzH97DFJ61kpCJ7JeDajYVr6JUMB/F1tBdEvZZTlkFT3biper4dFN16dUcSMxu3NBPM2bN3Jiy+uIhSK5OQSbkzl5DJD6gvkVIbj2A/+t+9fypvvHOIjH/0ot33sVmqGNQPmhlFm1p7FW3v3404ou+T1eqibM4uKzTtwp3ipXEg6D2vHkxllSU/tHer92IB2/dK0Y1Vrzyo1y4XD2xlf1UtH8ytEJk3rY/Tjo1UoHGD3+keZ8+Fvau4jxkAtKN6fKJR+BTScZKnVNFo7u4paw1K9aA8tW8+Dy9ZFFaed9vYOGhoauGjuhdQMGQbiVNo+9IwjO/oF5is9ZKtf5ToxsD1d1Wzf/gYNDdtwSz+//eFnmTZhdNp6VgqCZzKezWhYsemXMspyiFEchtlepb2ZMB4Ss52sf2ENF4W38TZT4rMXncrJlfoCFcMDHhPZsSM/yCO7jjFjRi0ul6S6uoYFH5pH3eyZNEyozehhTPwxKa8ow+UShMPaXqtUsdP6sdEqGq+5L5+PFSt+h9ttvRySv6uNGUO6cAkY5Gsg2Hk6kt5ZZ12jHx+tQuEA3b7jSb1IOwkUrfSGFYWhcPqVztq3NjFX7uhzGial5PfL1vPH5a9QXlnF2LG1AFRUVLJo0XVMnlqLcJ1CUhLfxt/ewr6//Sezbvsa3LxQU6es6ld1TRVTp01k05vbNNvppH51d/dy370PpLdJSoLBIDIcZtzIQZoGmZWC4GaMZzMaZjcBbK40TBllOcTIxXvX3Z8ztQ+r4/ahwHCOH+0lGDzzkI1u38VQcWbadIxsc3JpvUDFkKE9JrKEKmg+0c748YP53Oc+y4xZQ8EV6ZFm8jCm/ph0d/VEPW7aRpmZ4GYrs2K7utooKYERI61N2jjcsDpe3lPIMM2v/Znqj2gHrGb68UksFJ6MSPqBspNA0UpvWFEYCqFfyHJOHDvFzsZGfD4fFdESJKO69/VJDdv73nEeXrEej7eM6667jksvjSQvcLs9DB1aw7GjLUQ60Gc60W2vP0H3oV00rV1O3eI7NK+TVf3ytbbTsGUnXq+bQCDdc+S0ftk1vq0MG5sxns1omN0EsLnSMGWU5ZDy8lLNUid67l0tzKe9EPi7R/LK+q289NLL9PZGjlsmerlx0Jlp04m5vmI1HO2i9QIVOkN7oshy6l2qSuxNt9b6MQmFwpRXlBEMBG1NrjAaPtBCCJg0aYTp9WPnHhutFYQ5ufVp6vee5ANXmps9JsMhmvdt1v1xiq6VVcyYld6wonDkV78gHKpi3+4u/vKXx9mwYQOE/Xz9zg/j72pjnOsUgr6nYRPHjuDKi89l9cZ3WLt2LYcPHzZcv0z0csOgV/AISfPbL3PWFX9HSbX1lDh6xnB5RRkg8qJfVnNmanm+jry7kacPwlUXXZjmEc2kX3pesOiaRathyijLATG3sZagAWglsdGLuzA7E0aGRtGwZS9Llz7Bznfeief6+vD0bmSlJOY+mSHeo0L42SamsXDuebbP0anYMadJ7j1JFkzsxVgGtTEKir3l1kW2SstoxYhkorTM/CuqN717dPtunq9/ktGjZyQt0frxic1USvxx0pwJm8WQtBMTQRS5oxD6hSznWJNgxYpnWL9uHeVeyX3f+RTnThnLvteX4RZEndSSD7re4ZXwOYTdZUWvYR63m3/7ys2MHTWER57ewFunmg3X//D0bqgIgxvCoSD7X3iCGbd9GtCeSa5HseiXFSNOT79Gde9l+YbI94mGWSb9SvSC9SUNU0aZw2QKjoXIi2G0TaLr12zaCym9tLV30N7eRkWp4Ptf/ijl7iCBbY/ER9zcQlLLaYSABSM68e55Fv9Z9sbDiyF2LBVPuCctmelFY8I0d6b/uGRKemj0Y2K3FmBqAG15eSkIQXdXD0IIpMYsy94e8wKoV7ZqCJ0EgwGOH99juH3HqSaO73odSJ496cRwTiz+YuLFN3NiT/EZ84oIhdIvKKG7u5u2Nh+hUIAvfvI6zp0yVqNkGrhkgPO8Rzl77vV9QsOEEHzh1qtYOG8Wp32duutJf2eSXrsI0974IoH2W/FWlaStb6Q1+dCvWJzant0HdI0vKzkzjfTLTPygnn7p7duKhiXGjwE51TBllDmMmSSLVvK9xGI3rPZs5p47iaNbnuGESNadWHLWcPNu2sC2ABVD7FgqIwN700TWBZxTmpwA1UzwsZ0ccGb2qyeIWj+GUsL+/c1wmanT1ylbJXgzPA2AQKBHb1MA9qx/LOHYYVsxF3rBr7H4i93rH01/bpS3rGgoFv0qK4kMT2oZTkLAaNlM1altNGcR05NvDZs0diSTxuov3/f6sjS9RoY5vHo5tdd+HY8niLskkjMwk9YUg355vR4WLFhIb1dkckN3t5+uri6CoSDxoZsEMulXpvhBPf0Ca3GvWhqWGD8G5FTDlFHmMJnctVovRqa4C7s17PTH0yHWHbNr4Rc6dkyLilArUiafr8cNw2VycWAzwcdWcsBZ2a8eqcerqBhMS0uQ5hPZuv+JB0d7vfpVATpONdHtOx7/bLf3pxX8mhh/kXiMxGMV0phXnKGY9AsMNEyGad7/NtnE9BSbhunlZmx6ZwOv+aYwfPhwLrv8IgZVn8yoNYXWr+qaKq6evwh/Tw1PLH0WKcP4fG28+OKLdHV28kEN4zCTfhnFDzqlX7F2JGpYavxYSWU1qRO+nNQwZZQ5jFEwpN6LkatySbHEeLFho23P/W9SLwT6hpdi2LAKjh3byv33vUl1zWAWLLxMUyT2VlzOF249U6T8jW37uOveR7lw7sUkzhUzG3xs1CvUEjtbtUhlOTI0GBCcf+5ozj93PpIS3t35Hg8++KD+dhro1fwcQicet5dRo6YC2sKR2MuMN83is6EX/JostvHgIITLzcipFxf1szfQKCb9goj3RFe/+lBcopnEt4lG4o697/ONnz1MR6+kpMQNPMygQZU0N59kyZLrTWlNXvQrgcTjBXvHsOGVBv7859/S1PQ+UkIoGCQcCvClj13NJ26cl7a9kX55XW7D+EEn9Au0NSw1fkwIN8LlRoZDOdEwZZQ5jJ7bePHNC3V7G7ksl5Q4bKTVCyn6mB6PZNLkoYRCkUBXX2tb3KU+e/aFRlvqks2PiJGL3+p+e1tDvPPwv9Ay4TbC3uRr/8Ybb7Bt23ZKPIKzRpqrBRgT9U/efT/B0kFMmzaKQKCH6poqrvvgDRw8oF3o2d/V5ogHSyv4Na1oeUIPM5tnz+PCm3kthVX6mn5B8WuYncS3504Zyx///Yv8+q9r6erp5fCx07x37CS7dr3LiRMfoLq6Gp/Pl7ZdJg1zUr8i+dT+hym3fS2ltJObzg7Yu3cvTU3v45G9nD9jEkIIlsyfw+UXTNPcX6JRmmrE3mxQvcEp/YJ0DTu4+TlOHWxIih9zwiNnpF/KKHMYO25jO9uYIdOwUQy7PYp8JP8UZeByuZK+i7nU7Rpl2fyIGLn4rew3FBjBtqU/Qp5oZPfO+3jxcHLqC5/PR6knzM++9QnOrjWfFiNGS0sP06dfyfU3LKBy8DG62kdz8MAazXUPN6yO9/xiWO0B6s1kCwf9uj+mYN/LMaLKOybzWgqr9EX9Ante3XwlL161aXvcIIthJnB9zIgh/Ns/fhiAF1/bzg9+tTy+bMHCa1i5YoVlDXNKvwCOrF1Gx3u74qWdpPQiqEDgirzy0fd+9szJ/PwbHzNsVypzpkwwnRTYCf0CbQ07ue9tRMrvTyp2NMxIv5RRlgPsxFBkE3ehR6LVH3tI208coqsluW6a3R5FXpJ/pseDAtamWqeSzY+IkYvf7H4btu5mXf2vubjrFdwC6oa182ZTKZ1Bd3ydKWMq+OHXbmf8mEhx9Fz+iDgR8Kw3k63l/UaDuEb7sRhlJWKQ5Y0Upsi3fknpofWUl1dfXcP27dsRAoZUV2rq1+R5t7B1xf1Za1g+kxfrBahbSXw7ZHAlLgE7drzDq6++yk1LFrF4SS9rVq+zpGHO6FdjpEpMx2u4haR588ucdcUnOOmr5PjxEwA0N5/k9Y1v0NPdzdCayKuaKw1zasKGXkoOI/2yeywj/VJGWT8l0K3tubjgI9/O+oXIa/JPiaZhpuVST32ftFJMxLD7I5LJxW820/b04N74ebmE4J+uG80l131Kd7tsf0SMSpo7EfCsJ4wlFTVc/Hc/zHr/qRxo9u90fKeK/CPLOHbYzdIn/kp9fT3dXR18askVXDBlJG8v0047kO3zmu/kxTWVFZoGmJXEt3PPmcinP/z/2zvzOKmqM+9/T1V309AszSabCKKIoogoQTBEjYKvmoVEo4kmmZiQySR5zcwkk7xJPnlN5s0yWWayTDKJiTFOTDJqXIigISqoSIwg0EILyN6CzdbdQNM7VHfVef+ohVtV91bdqrpbdT/fz6eh+tate05V1/nd5zznOc9zDQ/8aS2PPPJHWltbuf329/OFL86BrGLmUazqA7uhX9FYlHUP/pTVR87mrbfeAjSdnZ20tLQw57xR/OOdiwD3DGGnNmxYbSoZMnKi45tCcumXGGX9lKPbX3QtB4+XyT8romEiujerqHjcpR4jFApRUREmFA7zh6f+xhPPrU+dF4vFiGlFZWUloVAYpWI5jRM7lBo/8/yqlwn1djM5dIxwIsFvWGlOH9nOLZ/9DtdcNY/P3Xl92pJtoTeR6sow3V3dbNu6jfPOO5/Ro4fR2XmYbdu20d3VTfWI4qoc5CJoO9mE8uB0z1g21a1hzZo1nO7p5J5PL+HGt89i37pl/UK/ABbPnZUWUwZQGc4duJ6JUoqlt1zNORNG8e1fLefpp//MyZNt3HbbBxg6NN24q6ysYsLEClRFdgypK/qFZlDLa2xev5eeXo1ScXvt3VfP4ctLb6IiHC6LKh5B0TAxyvopXccaXcnB43Um/8/ceh1f/ekjjB4/nEGDKhk8uIb/deO7mH3Z2WhOMfasYVw5bx6trSfZuXMnsVgs7fWThg1j4cKFnDNlDFo1l9yfUuNn2k52cIk6nHVcAddM7eORZ17lwP4G/u1Ln6B6UHauJjs3kX/+xC184fu/Z+3atRxtaqKmpoauri5279pFzaD480FEipQPPKJRiEQi9PX1cvaYwdz49rih4lYOMT8qkSRjo/LtvrTD4gWXMGFsLV/4/u95ac0ajhw5Qk1NTdo5Q4YM4cYbb2De/Aupqk6vIOCWfgHccnEfN9/xOYYPHUw4HGLokDMpeAZCFQ+n9EuMsn7KhTfezZDq7CzQpeJ1Jv+JY0fysy/fxT995352vtXGZXPmEFZnQXQshFsIV7Uwb8EUpkxdSkPDgSyjbPjw4Vx08USqqo861qdS4mdG1A5jZHtXapaZJKw0l50zjFc7xrNuZwM/+MXv+PrnlxZ1E7n4/LO5/+sfYd3ye3ngta10ROKxahPHDOGnX/s4E8ae2c0Z6W5n5wu/BaW48J0f871ElhQpH7goQ/kmt7wWflUiKSRwPR+XnH82D/7bp/nH7/w3u3akr4Il4+v373+TtrY7uO76BQwe2gyc0cVi9SvWN4phw2oZ2WWuX/POG87kRAyskWINYbtGTufxQ2x/5l4uufGz1IyeWPD7cgqn9EuMMiEnmQPD6RmsnYE3fOhgvvXPH+YjX76Xzs4OOrs60VSlQs1CFSeZMLmCCRPPJysALXQaVO56c14SXz7oyVg+qOQ9730/M6ZeyaLly3n44WYOH4/HoBR7E4kc3MjZQ/v45m0XUnXuNSiluGDqeAYPSjfUG+tX03msMfXYL2OoHJY3hPLEqDFueOD88PBOGDuS333/bnbvP5oWO6u15qEnn+Pl7W/xm988wMmTbbz73TcwfNQJVFbsmX0ip8ay/pUd9PXV8NfYJWRGqX7g6nnMmT7V9LXFaphdI2fP2oeJ9p5m99qHmPP+L9p+T07ipH6JUSbkJHNgGAu8Nu1az7gZ80u6kdsdeJUV4YS5ZRUV1gfh40X3wyuslw8m03ESQKEMhmUxNxGjQESP7SAUPcmF191FVYZBFulup2nPhtTvzXs3+mYMDYTlDcEfjBrjtH5lXt/L7+zgQVXMnnFO1vHZMz7JvY+u4aGnX+HRRx8lHA7x7ndfx9DaExg9ZvYI0d0xltWr/sYjj/yRgwcPctZZQ5k2bQzV1RUMqqhkycIrcnoBS9Ww5r0b6Tp+MK5hGdpkzOTf09ZE1/HDvnjLnNQvT40ypdSNwH8CYeB+rfX3Mp4fBPwOuAI4DnxQa73fyz5aka+AdX/Eyvq3OyvIN4McqN6RQpYPilnGSROIaJTOY42mItFYvxoMYqmjUV+MIT/ifAYaA1G/wFxjAEf0y+r6fn9nQ6EQ//tD13G0pZU1m3bT1NREV1cfw2qr0OSuf2sknqqklqdW/Jlly/7EiRPHmX/pecy5KG4Izp05lZnnTcp7HTc1LDOTvx/eMqf1yzOjTCkVBn4OLAYOAhuVUiu01sZF8aVAq9b6fKXUh4DvA4VlnXMBO4Va+yNW1r/dWUG+GWSu6wQ56NvqBheEG1+mQCQ9i8170r1gmV6y5Ll+eMv8ivMZKAxU/QJzjUn8knasGP2yun5QNKyy0vz2bku/Rgxn/vwbeOONQzzxxBN0d3UwY8p4brzq4nhFeOJhJW5gV8My612CP94yp/Urd6paZ5kH7NVaN2itI8AjwJKMc5YADyYePw5cr4zRnz6RKwtyf8XK+u86ftj0eKS73fT1yRlk1/HDbPvLL1LnWV0/+bxREINE8gaXzPWTvME9tXy16fH6LTs87Z9VUV8d60v7LDO9ZKnzEt4yJ4h0t6f9za1wa6edEGcg6heYa0zz3o007dlQsn5ZXT8oGvbHZzbw3CtbGTykhpG1Ixk8uAJNr339amvn+eeXc/Tom5w6dQqNYteBJv71lyv413uX86/3LuejX7mXFzc4r292Ncys3iXEvWVO4Jd+ebl8OQloNPx+ELjS6hytdZ9Sqg0YDRwznqSU+hTwKYBzzhnvVn9TlFqotRyxsv7NatCZzQoyZ5C71z5ET1uzqbct8zrJeomZSw5BwOoGV7dxa1ay2uSNz0tvhFUCRCDNpW4tGNoxY8hurE1Q8gN5iZcaNhD1Cyw0LBolMy61GP2yvH4ODfPKW/bDB5/liVUbGT6ilve85z3c/K4bGDayHYgWpF99fb3U1HSzZMkSWlvTc55FIhE2b97MPT97grvvWMyHbs68lRePXQ071WkeQ2x1vFD80q+yDPTXWt8H3AdwxdyZpeYDzUspBazLFSvr/1Tn8byzArMZZNLNnBxUuWYXZksCQy+43vH3CIXH2ljdyKyqB3h94zMGMjcbPAJAqsBupPMEMxcvdfUmEcRYmyDhpYYNRP0Cq5u7mQemcP3KtxPdy40rxuLdI2oGs/mN/ahQiNmzZ3P11e9g9Ng+lIoAhetXV1c7N998PR0d6a87fTpCT08Pr9XV8fgzf+WDN83DqUUtuxp2xa1fdU1T/NQvL42yQ8Bkw+9nJ46ZnXNQKVUBjCAe8O8rpWZBLkdKsf6t3M9wRqCsrh/pbqfuie9mLQlUn5M5EwuhqM6+QAHUb9mWFWvz7J/+TO9LDzL7E9+gctgIIJL2GqsbnFLKVNjcvvFZxa1Y3TBaG3cQjfS4Hq9Vyk3J71ic/sZA1C8oXsPs6JdxJ3omVhrmxo19894DadUCTnW18ZELW3k8PIxXXnmF3t5ePvKRD3PJrDGEKnoYUTuctpPZy3FW+jVo0BB++ctf0dbWlnY8Go1y+PAhRg2r4Ptf+mjRBlmuse6nhpVqVJeiYV4aZRuB6Uqpc4kbXx8C7sw4ZwXwMWAd8AHgBZ2rgKFHlJoF2Q65PDZBCCAvhFzu53wCZbUk0L73ZZSC5uYWtm9/g3HjxhMOlzYze2blmixX/rnRt4gdb2HH8kepveozTJhYS2V1C8kZttUNbvacmdRvfsPzG5+Vi93shpG8Wbg9+yt1N5IkkXUWL/QL+o+GlaJf4O3GlVWbtqaVb5quDjOSDt41o4bft1Wwfv16OjraufPOO5k0aQKXzrqWV15ZSTR6RqfC4QrOP/9S9u59Pe24UiHefPMEu3a9xaCKbK09f8JQfvjVTzCmhIlnrrHul4Y5sZuyFA3zzChLxIjdDTxLPCXGA1rr7UqpbwKbtNYrgN8Av1dK7QVOEDfcctJ09Bjf+NqPXB/opWRxz0eu3VFAwTunhlbF2PP8r7nonR/1xdNgHExWLmirL6vV7Oj0ycN86vbF/NfDz/HEE8vYtm07oVBpRtnw4Z0YJ3iDiDBZHUMBXbue49G6Ht729utZdMNChgxrQalYzhvcOVMm5bzxOH1jKtTF7tWSSik3pYG47Hn4UBM/+vdfl61+QfEaNv28yVnX8ttTWop+gbcbV4yFzlP6pWB8rIkHvvEFvvAfj7Jt2zbuvfdexo4dC0BlZZjq6ihKabRWdHeH2bBhd9bxt946yf43j3LTwkv5pw8vYkfjYdbU76C9u4fhQwZzw9xZJRlkxYx1LzSsVKO6VA3zNKZMa70SWJlx7OuGx6eA2wq5ZjQxS3B7m7ebM718u6OsnrNq/9pzTtHVcsCxL2wpIlmoQOVacrgMmHjWCH7460e5KvxX/mfbEDoixW8gvnL+uVRXV6Z+n26s6RaLMfrkOp5YdpIRtbW845rLCFfGV9utbnC5bnxupCUoRKC8zAVWyk1poCaR9SJNRRA1bPp5N2Rdy2lPqZf6BfmXTZ00OmtrhqQMM6N+KQVt+17h19/+DF/7j/9m/Y5GDh1stLqMKWEF/3D7O/m791zFln1v8ZcN9SmvXHt3D8v/VodSqujyUYWOda80rFSjulQNK8tAfyvc2u3mdp6fYnZHWT03JNzL5ePicVBOfWFLEclSYtPMxOvqK2YwumM6bfvr+NYHplJ93juLvv7+5hY27GkgGoulZpnJmm4VYbhyYoQtu9rp7uoi2hciXJnngjnIddMq5jtUqEB5uaRi/JsXcgMa6Elk3dytWy4a5oanNEj6VWp/Mlk8dxZPvryJULQnTb9Chs/vB1/5JHveaiISKazMUu3wGiaPHwVkL5MC9EajrNq0tSijrJix7pWGFatfyfNL1bB+ZZSBO7vdnL6hZpJvd1QhO6euHN2SWpJz4gvr1nKSnS+7mXhFuttpb6wHIHpsJzOueV/R/Zl1wWTOHj+aVZuS+iHrAAAgAElEQVS2cnb3fjJjVZWCq846UdS1M3E6LUGhAuV1LrDk37dq6CjbNyBJIuvebt1AatiI4UQivXR0dNDX2weDnPeUBlG/nOxP0iDat+4JyLC5jJ/fjKkTim4D0pdJ7RzPRzFj3UsNK0a/wBkN63dGmRu73dzO85Nvd5TdnVMq0sbFI1qpSKzoOeFpcGs5Kd9s0Uq8nO7PnPOnMOf8KWxZvofu1vTBVBGCyTU9RV/bSClpCcxuAE4uC7tB8u9L037s3oAkiax7u3WDqGHz59/A448tY8WKp+jq6uTORW+jee8aRz2l/V2/IK5harvK0i8di9J+tKGkaycxLpNmHrdDpoa5sSzsJMXoFzijYf3KKHNrt5vbeX7s7I6yEwtS1biKzDw8pZT+cGs5yShYTbvWM/6C+dSMnpjWNzPxSiZkdGN5K3PA71u3jCM719HYNZjsUOTCKSUtgdkNIMgJV41/3yR2bkBBfk9e4OZu3UBp2IjhzJu3mC1b3mTFiuWc7unm7juu58pRh2neU176ZSyWDQRKv5p2rWf4+GklXTdJcpnUuIRZGQ6zeO4sW6/P1LAgj/Vi9Quc0bCyN8rC4TCAq7svp19wLps2vJ52zGkBzRUkbnfnVEX7fsIZce+ZVnoh8QxuLSelX1enisgm+3agbiXH9tdniVe0L+LJ8lZyUIYUzBrVTltv6d6EfDet+i07WP3sA7S3tzLr0rH0tnWl9cXL3YilBiKbfm8GWHxYobipX/VbdhA5Hck67puGxcbyxrZmdu16llPd3XzuzkV86Ob5bFn+47xehqDpl7FYNhAo/XJSM5LLpMkktbU1Q1g8d1ZaPJkxia3xea81rNz1q+yNsnHjx/D/vvMF165fv2UH9ZvfyDo+e87MwOXZ6ZrzRR544DccbzrIU7/4EkOqq9KeL3RwuLGclF1sNl5E9uSh3Wf61rA563WxWJRjDZtBxxztjxnGQanQ1Bx+Hri5sIvowaDTk9vOvvQqZl96FZGO4+x7/Lucf+6FEBtJfX09Ty1fRW9vLwCDBlVQNWYYm/ceYHhLHToWf8+xWNST+KpSApHN/r5JBlp8mF0mThrHF770965cOzPAP8ngIdXc9K53+qxhGqU0F0yNl5mys2sxePoV14mm3RsSCVSDpV9OjrlkqEfK6Jl4deq5zCS2J7u6efLlTQDUHFmHTuQ/80IDyl2/yt4ocxuzAFmAPbvf9KE3pVHoYHXDxWyVLXvXS384czxDuIzHxs1Y4OqgyByUFSEIH6+jt/M4VYPtXSPWN4qGvR20th40P2HbH6BxO1seuw8u/gjPP/9MyiBLokIh1mzcxPy+TWc+Dx1zfbZW6qw2Zzb0ARYfFgSs9KuqqjJwk8p8BFm/0FG0Tu6wCo5+ueHhMTN6rHZnrtm4iStPv5Y65rbHqT/olxhlCaxy+PSXYr5BSTdglS07GkkPqA+FK7n81q9QNWT4mbIl0T5a9m5i3AVXsn/DcleSS5oPSk3T337LtPfdnvf1kVNjeXXdTh577HFOnMjeuTkk3MvHz91JRUjTu/8lfvtiE+On1JiWKRnXsw8dThd4t71lpc6yrf6+Q0ZOzFmWRsoqlYbolzfkyvZvjEHKpV+TZy8CcOU77/YOZiujx2oX5sSe3RDybkd1f9AvMcrIncOnvxTzDUq6gcuWfN40S3Ymxr5lDrTdL/2BU+3HOFC3kunvyFv0oSDMBqXSUboObgPyGGV6GIcPdvLSSy9Rv2ULVRWQaWq9Z3o3SfFWaGZV7+Pg6ZlpSWyTjAl3Z8+6dSznbK0UgXDixleMd8LpZKEDDdEvb/ULzDP9W/UtU78O1K3k5OHd9PZ0Ot5/t3cwWxk9Vrszx4Wy62zm60+xGtZf9EuMMnLn8OkvxXyDlG4g92wzTrJvZgPtVPsxAFoaNjPlipttDzg7g904KN/1D9+jomYUn/j4J1h0wzuAfBmxQ0Sj0URQdYx//MhN3PSOS1PP9va0s/2pH6ITb70iBAvOiRGafSkrX9udtbNpzNtu53Td71PxGBCfgc9cvNSyB6UIhNmNLxbtdcX4TTIQyyo5jehXMPpjJJd+tex7jeTErJDvfKH65TS5jB6z3Zk14ShVIQ2GeaXRg2hFsRrWX/RLjDJy5/Dxqpiv2wRpC3Ihfdm3bpnlGj+JWafdAee1R2ZwdRWDB1WlxHTQ0FHZ70VrxnTt4X0L52btXBreUkdzAd6BUgXC6kbTenCH7WsUiltByQMJ0S/vsdsfc/0qPNUC+OtRjnS3U//UTyy9lXMMsWVJDbum9jixZtKSNNktB1eMhvUX/RKjjPwufreL+QrW5JuR2vWW+emRSYppxckmy9n+nAW3ZJUr2bJ9WUHegVIFIrO8SDIOJtbXS6S73fHPKyhxQuWO6FdwseNRs/Od99uj3Fi/mt6e7O+YUY+SuzOTbFn+Y7oL9G6WomH9Rb/EKKO0xJ6CuxgH2p6/PkLLvrq053UsxoqH7mNndEbO61wQ3sOEcJSwgt6+Pp586H52R6fnfE1PJMqwGrIDwwrAKKaxvl7m3n6PK/ENTguEFx6soMQJlTvlrF9aKxoOtnD5zKl+d8UVMg2FTY9+m3Tfkb3vvJ8e5TMaZm/5MUmh3k0nNayc9UuMMuxloxb854SJG1opGBFr5rl11rPRYVUx3nHlCcIJ4yqsNGepI/y27jSdkZDl60KhKs49dzyvv76KV19dVtT3wisxtSMQdgNovfJgBS1OqFwpN/3SqoPRo2s5//zp7Nyxk//8w7MoFeLWxVf43TVXiSeYzQ7FsBP4Xux4tEroWnC/y0jDyl2/xChLIC7+wvA6jUEsFqOlvZdRg7KfU0NGc8edd1i+dtLJFwl3n8QYcVoRDvHpRZM4VHut5etO9bRyonUfPT2ngPRdbXa+K6qvm+Y3vVmesyMQdmNSvPJgBS1OqJwpJ/1S6hRnTdR88INLqKys5Omnn+aHD66ko7uHu5Z4493zIw2L1c06V7oFKH485kroatcw8zLEwCkNK3f9EqNMKAq3gk6txLKltYPH9o/hkxccJaw0Ua14ITabaMUQbrrhNj58sfUse+9v/8Kp7vTUEiFinF3Tw7Ufvs3ydb/4xbeJRs13tdm5AQ46sdUTcYh0t1NRNSjn0qhVTIoTxc4FoVCUOs3YCVFu/+CtVFZW8Pjjj/Pc2g2eGWVe6xeAvvgWXnz5Fa7Wm1MatlbN4eaLr8p5zWLHo1VC11Wbtto2yrwwcJKf2czFSwuOq4PsfG/lrl9ilAkF42bQaS6xXDQtvX7fdHWIbX1TWfvXp5g7f7zlNWd97ls5Wjxk+Ux7e6vp8XyJNwdxis9c0UW4xzqw30kKnT0mcyWd7jzBoKGjyqrYudB/UKqP6upB1NbWUllZCWTX53QDv/Rr1aatnBtrTItRPTfWmNdIKnY8WiV0tTpuJGko9Z7qdl3DivHg58r3Vu76JUaZUDCFxBgUskyQSyz7TnUwteIEYRVvN6w0kznGHj3JtezkxSbenB7axZTaKL2Dx3H1h/+vK31LYucGY7oE0fBa/G/YvD/nawWhv+GHfgH0dJ1kcuhYtoZ1tTnzxjKwSuhaWzMk72uThtK4GfOZ8/4vutE9wL6B7GS+t6BjHeUsCCZYxRhEurMzN0P6LCjXNbf95RccqFuZJZZJWne/jFmQ7HR1yLXs5NMvOLeg4wCxnlbOCb1FSEFVxz7Lz8UpzG4wuc5Jkaozmvu1gtCf8Eu/AC6uajZ9vdXxUrlg8oSCjifJNJTc1DA7+pV53hmy8731B8QoEwoiV4xBJsbB3bxnI6//+WemAzwufG/S0vCapVieaj2Y2j2ZJKw0o0Jdrm39tyo6n6sYfc/Wx0iJhdauCoXdG4zdCgpuC7AgGIlFh7P/zUY2b95MV2cXg6vcX7jxS78AJlX3prxkScJKM6nanWXb3Y1HCjqexK6hVCqFGMh28731B/0So0woiEKCKNMGd6yPzpa3sga4MQdOLrGcfM3f87U1tTzYfAWrK6/l6ejb+Ouw6xhzy5eYfdlM4oEazv7kLuacfX5vRyunG15MCa8iVpRQJGfe+V5n9wZz2ZLPM/f2e8iXcK0/zTaFYBPtHcOmVw/xy1/+ipdf/htDB2m+/Ok8tWUdwC/9Alhw25cZvPBuXq6+hqejb+Pl6msYvPBuFtz2ZSfeWhbFxJQV6km0uoaT+gUkSssNDP2SmDKhIOwGUWYO7iTNezemrf2bu6XjGOvH7X3xfubPmwRVimg0yqLFt3HhjMsBaDkCfV3HaVn1bcbecA8VQ0aV8A7PMGxYLR0dJ02PtxwZk3X82Nr/RMeiadJRzE4lu4Gvhdxg9tetxGz5185r7eJHmgGhDNEj2N/QzooVT7NlyxYmjx3Cz7++lLEj3f/O+KVfu1/6A5Ep17L69QbLnGFOj59iYsqc2G1ZrvoFwdAwMcoEV7ASKx2NpgarqfCpEHNv+1ragHj1mQeh8yizqqNs01Pp7T3F6lWP88LzLxIOx+PJLorVMZl9vPLgV9kRyk6PUaV7mK3XU6/mE1GDbT0fjVYQn50Z34eiq6uCX/3qvqxrLIj9leEUv1Mp0t3Ozhd+S9eJI9gJvi/kBnNs32s5z8mXK8kOftbmE8oIXcXp0yfp6GgnrGL8y8ff64lBVghO6te+dctob3qTt5q6ORk9BzDPGZZv/OQzGDKfNysSXhkOs3juLMv3XUo6CT/1C/qPholRJriCdQzAmcFqHoCeXmQ80t1O5OgbhIHJKr7b8jSVgKar6wjr1/+NYVUxrnt7JyoM46P7eGBtEx0ZmfpvmdFD7dm9VDY+w9O7so0yq+fPOmsY06aNpbq6glOn+mhoaKG5eafpe34OUAznqpln8Z0vfoJBVZUFfGJxQeg81kjSTe9UPiCrTOLgjJCB/7X5hPKlsiLsdxeycFK/ksubk3Qzu5iQ0K/0nGF2xk8+gyHz+aSxV0hG/1K0oJz1C4KjYWKUCa6QHCj71i2jec+GNIFLDlYr4Ws1lFNKCV9iTXC6OsQ2PRWAwYMr+T8fv5lhJzZR0dUAxKgMh/g/N42nY9Tc1DVC0R7GHH4aBbz9nBgzrnwnsfBg288bufqiC9NeN+L4K7SNvip1/qgRNbzj8gsIhQoL14x0t9O0Z0PyE4r/G4vSvHcjXccPcuF1dxUtEFaz3MEjxjkmaH7W5hMEp3FcvxIY9QvOxHflGz/5DAar5zOLhBtxcqnOSr9a9m5i/AXzeXPDk0W344V+QXA0TIwywVVyucMvW/J5It3t1D3xXbQhc36srzcVJNq8d6NpbrLTVFJbM4R3LZhO3eOPoxMllBQxhp46wNUL7kgJwL51y2gOgY5BSMElw5rTBlu+563Yt24ZTYeP2T4/F431q8FE4HU0SuexxpIEIlO49q1bRtOu9QwfP62o62XiZSkWQfASJ/Qr+fpM/YJ4fFeku53mPbnHTz6DoRiDwsmlOkv90jF2r32InrbmottxW78gWBomRpngKvlmMnl34JjEdUxXh9gVOo/Fc2fRWL86WzQNotR5/BBNu9aTOXszlhkqZjA66epO28GVhbPJEd1w0XtVa04QvMYt/dqmp6biu/zQMK/0S8ei9LQ1Ac5omFtLjEHSMEmJIfhKrpmo2XNhpRkT7uZ9C+cy5/wptDc1kBlvYAxM3bP24eznDaJZyLZsI07m8jHrgwqFGTxiHCoUdqQNs7acuma515oThGIpRr9Gqi5qa4b4qmFe6Ne4GQsYN2OBoxrmVg61IGmYeMoEX5m5eGmW+z8UrsxbnDbJ8HHTONV+LJ6KIhTmrOnzUjObSHd7apZmxDjYihmMTru6rfpg7LsT7nS3XPTlXmtOEIqlWP26yfDYaw3zSr/ajzZwqvO4Y+24ucQYJA0To0zwFbNZVizay/66lVyQ2MFkRb5B2li/GhUKp4nd5NmLUsGtUNxgzOfqLjSA1qwPuQKMi3WnB8lFnyQIeYEEoVhK0S/wR8O80C+Ia9ipPccs2ymUgaJfsnwp+Er70QbzHUyNO0zOTifXILUSuwN1K7Nq2dnNQJ0k38zUTr28Utuw22/jOW676Av9HMGZz0oQ/KIU/QJnNCyI+mWnnaDpl90+GXFDv8RTJvjK8PHT6GlrZtyM+UyevSi1FKCj8R1MuWYfuQap6Qw2FqWl4TUyg0QL3YWUa2bqVCCqndmvnX4bz3HbRV/o5xiUvECCUCyl6Bc4o2FB1K987UDw9Mtun5K4pV9ilAm+kfmljvZFCtrWnWuQbln+4+wZrI6deZi4/uTZi2wNLLtuaq9y3dgRBC+NnmLaCkpeIEEohlL1C0rXsAN1Kzm2vx7RL2/6ZMStz0qWLwXfyPxSH9v3WkmFcI1ctuTzXHXXv6d+5t5+Dyp8Zg6SvP7+upW2dvPYcVP7VczXqt9u7VQqtj9GnPisBMFP3NQvsKlhDZvRsViqD6JfxVNIe27qlydGmVJqlFJqlVJqT+L/kRbnRZVSWxI/K7zom+APZl/qXNu+S8UqdsOOkGbOoKwGXrHpNTKv4YR4emn0FNOWE5+VIPiF1/oFFvU4dSzlPRP9Kp5C23NTv7zylH0FeF5rPR14PvG7GT1a68sSP+/1qG+CD5gKTAbxgVHnyEC0it3IJaTJWd8Bm960UgNRnRLPzuOHqHvs39DRqOU5TlKMQAUpL5AgFIrX+gW56nEa2swYd5Huduqf+kng9SsWi6bp7pYVP0pLM5Kv76VSqIa5qV9exZQtAa5NPH4QWAN82aO2hQBiJTDGArPJchpOrNWbxW5s/tN/ZOUASubXgeSs701o3n9G1HLkxik1ENVujEI+Qdiz9mG0Nil54pLRU4xABSkvkCAUitf6BdljZsvyH9PdejjtmFG/APbXraS3pyPt+SDqFzqWtvuz71RX1uvcnLQVqmFu6pdXRtk4rfWRxOOjwDiL86qVUpuAPuB7WusnPemd4Dn5vtReBHkad06dt+CWtJpqaaVDTGZQ++tWEuk84Vh+mkISI2bW3AuFK7n81rjzuX7FT9IMzdnv+Tw1oyeW3L9ciIElDDSCoF+XLfl8SrPGzZgPkFYTMtLdzrF9r2W9Lgj6lXyNUcNmLl6aKCm1LnWuCldwxa1fdX1XdpA0zLHlS6XUaqXUNpOfJcbztNaazDWjM0zRWs8F7gR+opQ6z6KtTymlNimlNh1raXXqLQg+khkg6naQZ6Zodh0/nPa7cQNAJjoWpbVxh6P5aQp1n5t9Po31q+k6cSjtvN1rH3Kkf4KziIb1L7zWr2SbSc1q3ruRpj0bMC4dxtvM1rAg6Ffma5LnxktKGa4Rjbq2ZBlUHDPKtNaLtNaXmPwsB5qUUhMAEv83W1zjUOL/BuJLnHMszrtPaz1Xaz13zFjTPQNCmWEMEPUiyDNTEHavfchyJxXES6fMvf2e1C6oWDRCvtiJQrAsVdLUkHWu2efTvHcjTbtfzTq3p62JruOHs44L/iIa1r/wWr+SbaY0KxqFZHuJVBmZRcKTGualfrXsM4+pM9WwPRtNSkrFDc6BtCvbq+XLFcDHgO8l/l+eeUJiR2a31vq0UmoM8HbgBx71T/CRTK9VzJDvJ4kxr1ipZS3MBCGzzmQmxhgJN/LTZLrPU0up46ZlnWs6K41mb1pIsnvtQ8x5/xdL6p8gCOYUol/FlDHK1eYZrTrTXjJVRiZpniuX9Qtyx9SZalgsPbA/dTzhLRsoOQy92n35PWCxUmoPsCjxO0qpuUqp+xPnXARsUkrVAy8Sjyl7w6P+CT7SWL86lWsnFovSenBHzizXpbrd7eycyiTZvhez4Hy7mMyDjK3fz6nO4471TRCEdArRr+T5rmuYIVWGsQ/tRxs88eIVp2FW6AG1K9sTT5nW+jhwvcnxTcAnE49fAWZ50R871G/ZwfOrXqbtZAcjaodx/eKFzL7sIr+71e9IDd6kgOgYsb5e5t5+j2mG57onvoud4NlIdzs7X/gtKMWF7/xY2nl2BcG4kyrJvnXLcs6CSyE5g64aOirnTNasT5nFy5PFiwfK7FLIRjTMfQrRr7TzbWhY5/FDbH/mXi658bNZm3XsaJiVfjlZJNyI0QOYbzVBNMwaKbNkQv2WHTz15Cp6e+Pu1LaTHTz15CoAETWHMc4ykyRz1uRyeecTksb61XQea0w9ziUIheBmfprkDJqm/SQ9X7l2MXnRJ6E8EQ3zhkL0K3m+XQ3bs/Zhor2nTcMPitUwL/QrWfrJzk5ML/pVbohRZsLzq15OiVmS3t4+nl/1sgiaw3Q0H8hysxtz1iQpZMt1pLs9sRMpTvPejY5sSY90t1NRNchyFpzvtbniSIwz6EzyiXeQtnMLwUA0zBvs6hcUpmGdxw+l4lyTm3WcSG0zc/HSouLZCtGvXPFsomH5kdqXJrSd7CjouFA8MxcvTavnBqRy1hgpZMt1Y/3q1E4ksL+tOl/dtlJiQfK9NleMyECdMQrFIxrmDXb1CwrTsMzUEHZT27ilYQXpl0U8m2iYPcRTZsKI2mGm4jWidpgPvenf5BIq46zKrns700uWONOWt8woPJkzulKSQeZ7bfZOKlIJYd1Omij0T0TDvMGufoF9DTN6yZLY9Za5oWGiX94iRpkJ1y9emBaPAVBZWcH1ixf62Kv+iV2hsuvezvSSpa6ZZ1t1PuEpJg2G3cD9QoRdEOwgGuYNhcRC2dWwTC9ZknypbZzWMNEvfxCjzIRkzIXsXLJPsbl3nI4lsHaR595WnUuwCokFybymncB9CXIVnEY0rHCK0TA3YqGsUtjkS23jtIaJfvmDGGUWzL7sIhGwAsjlNveSYkQyn2AVMxMsJHBfglwFNxANK4ygaNiCj3634NdEuttp3uOchol++YcE+gslky9RYNDJF4BbzEzwQN1KdNQiQ3WRs8h8QbyCIBRHf9CwLI0qQcPc2Hgk+mUP8ZQJJeNG2SEvySdYhc4EI93ttDS8lnbMicDXoMzkBaG/Ue4aFq+Rm1m2qDgNcytwX/TLHuIpE0rCq+K7bnLZks8zbsYCVCgMxDNJj5uxoGi3fMOrT9re+m6Xcp/JC0JQ6Q8aNnzctCz9uuqufy9Kw8wS4op+eYcYZUJJFJJ7J6g4LcqtjTuyjpUa+Go2k/cKWXYQ+jPlrmFO65dZQtxy1i8oLw0To0woif6w88ZJUe48fggdS48lC4UrmXv7PVmzVrtC4fdM3okCyoIQVMpdw5w2Ks9feHvWMbOEuOWiX1BeGiYxZUJJlLrzpthUGk7ipCib5RiyilGxG2PhZx6gUpLmCkI5UIqG9Tf9AvsaVg76BeWnYWKUCb4ShOBPp7Z0R7rbszJxg3XlAbtC4edMvtwDoAXBTfqTfoF9DSsX/YLy0zAxygTfCMoMxqnZbmP9alQonCZAKhTmrOnzTL1kdoXCrzxAxSbNFYSBQFD0K9kXLzWsHPQLylPDJKZM8A07wZ9eBGgeqFtJe9ObHKhbWVK7hdTn9DvGwg7lHgAtCG4SFP2KdLdT/9RP0mKmim3XjoaVi35BeWqYeMoEX7A7g3F7ecCYU6ylYTNTrrg5lQG70HYLqs/pUoyFkzEufi87CEJQCYp+AeyvW0lvT7z4fLIPxbZrR8PKRb+gPDVMjDLBF+wMbC+WBw7UrTzTDx3jQN1Kplxxs6vt5hIKoygBBQuUkzcBK4FOzsL9DG4WBD8Jin5Futs5tu9Momqd0LBj++tda9euflUNGV6wkeW0EWumYck+RbrbA6lfYpQJvmBnBuN2gKZZ5v2Whs3xvNgutptrNrpv3bK0ZYhCBMqrGJcgBDcLgp8EQb8g7iUzZvLXsSgtDZvP/O6jfp234JaCtEL0K44YZYIv5HOTexGgmeYlS6JjiZmndq1dK4yi1Lx3I1prChEoL24CQQpuFgS/CIJ+ZXrJUhgSv/qlXy17NzH+gvkFaYXoVxwJ9BcCiRcBmq0HszPvJ1pytV0r0kQpGoWkoNto36vgW78zcwtCOeCFfsWvZV403M12c/bHoA271z5kWytEv84gRpkQSNwI0MzckVQ1pNbW6+y0W+ouq+wiwBlLEnkEyoubQDntuhIEP/FCv+xey267pWiYmTb0tDXZ1grRrzPI8qUQSNzIbZMZS2BW9qjYnT+lximYiZKRfO58L3YZ+Z2ZWxDKBT/0C/zTsHz6Bbm1QvTrDGKUCQMCO7EExYqSE3EKZqJkJJ9AeZGgsRy3lwtCf8CuxvilYfn0C3JrhejXGcQoEwYE+YJISxElJwJU/cx6bZdy6KMg9EfsaIyfGlYO2lAOfQSJKRMGAHZiCYoNAC2XOAVBEMoTuxojGtY/EKNM6PfkCyItRZScDlD1oiyLIAjlgx2NEQ3rP4hRJvR72psacsYSlCJKTscpGGNCBEEQ8ukXiIb1JySmTOj3DB83jZ6TzYybMd/xnT9OximUQ2JDQRC8JZ9+gWhYf0KMMqFfY0ckghIA6kVGa0EQyge7Ro5oWP9Bli+FsqOQmIVyyOAMEmwrCAMJuxpWLvoFomFOIUaZUHbYjVkwE4nmPRsDKRJeZLQWBCEY2NEwM/1q2rWeruOHvepmQYiGOYMYZUJZkenOL7j0UKwvkCJRLokNBUEoDbsaZp4lX8drSgYQ0TBnkJgyoawoJGbBKst0+9EGV/tYDEGJCREEwV3sapiVfvW0NRHpbg9cAL1omDOIUSaUDVYxC/mCX/etW0bzng3oWBQVCjN8/DRP+y0IggCFaZjRyMnUMAmg7794snyplLpNKbVdKRVTSs3Ncd6NSqldSqm9SqmveNE3oXwoJmZBgk8FQQgKomFCPryKKdsG3AKstTpBKRUGfg7cBMwE7lBKzfSme0I5UEzMggSfCoIQFETDhHx4snyptd4BoJTKddo8YK/WuiFx7iPAEuAN1zsolAXFxCxI8KkgCEFBNEzIh9JZuztcbEypNcAXtdabTJ77AHCj1vqTid8/Clyptb7b5NxPAZ9K/K85kVIAAAcxSURBVHoJcU+cn4wBjg3g9oPQB9/arwhROWlk1bRDrZGTfTGa/OhDAr//Bl72YYrWeqwH7bhCwDRsIH1vgtq+r32oCFE5cWTVjMOtkZ19Mfr86EMCv/8OvuuXY54ypdRqYLzJU1/TWi93qh0ArfV9wH2JdjdprS3j1LzA7z743X4Q+uB3+0Hog9/tB6UP5UCQNMzv9oPQB7/bD0If/G4/CH3wu31w0CjTWi8q8RKHgMmG389OHBMEQRAEQej3BCl57EZgulLqXKVUFfAhYIXPfRIEQRAEQfAEr1JivF8pdRBYAPxZKfVs4vhEpdRKAK11H3A38CywA3hUa73dxuXvc6nbheB3H/xuH/zvg9/tg/998Lt9CEYfyg2/PzO/2wf/++B3++B/H/xuH/zvg9/texvoLwiCIAiCIJgTpOVLQRAEQRCEAYsYZYIgCIIgCAGg7IyyAko27VdKbVVKbVFKZeVF86gPrpSNUkqNUkqtUkrtSfw/0uK8aOL9b1FKObJpIt97UkoNUkr9MfH8q0qpqU60W0D7dymlWgzv+5MOt/+AUqpZKWWaV0rF+Wmif68rpS53sn2bfbhWKdVm+Ay+7nD7k5VSLyql3kiMg38yOcf1z6Fc8VvD/NavxLV90TC/9ctmH/q1hol+5UFrXVY/wEXADGANMDfHefuBMX71AQgD+4BpQBVQD8x0qP0fAF9JPP4K8H2L8zodft953xPwWeCXiccfAv7ocft3Af/l4vfvauByYJvF8zcDfwEUMB941Yc+XAs87eJnMAG4PPF4GLDb5O/g+udQrj9+a5jf+pW4vuca5rd+FdCHfq1hol+5f8rOU6a13qG13lUGfUiVjdJaR4Bk2SgnWAI8mHj8IPA+h66bDzvvydi3x4HrlcpdX8vh9l1Fa70WOJHjlCXA73Sc9UCtUmqCx31wFa31Ea31a4nHHcR3S0/KOM31z6Fc8VvDAqBf4I+G+a1fdvvgKn5rmOhXbsrOKCsADTynlKpT8ZImXjMJaDT8fpDsP3yxjNNaH0k8PgqMszivWim1SSm1XinlhOjZeU+pc3Q8zUkbMNqBtu22D3BrwuX8uFJqssnzbuLm370QFiil6pVSf1FKXexWI4nlnTnAqxlPBeVzKGf81DC3/35+aJjf+mW3DyAaNmD1y5OC5IWinCnZtFBrfUgpdRawSim1M2Ghe9mHosnVvvEXrbVWSlnlNZmS+AymAS8opbZqrfc53deA8RTwsNb6tFLqH4jPeq/zuU9e8xrxv32nUupm4ElgutONKKWGAk8A/6y1bnf6+uWM3xrmt37l64PxF9GwLAa6hg1o/QqkUaZLL9mE1vpQ4v9mpdSfiLuNbRtlDvShpLJRudpXSjUppSZorY8kXKrNFtdIfgYNKl4Mfg7xeIZisfOekuccVEpVACOA4yW0WVD7WmtjW/cTj13xEt/LhRkFRmu9Uin1C6XUGK21Y4V2lVKVxAXtf7TWy0xO8f1z8BO/Ncxv/crXB580zG/9stWHga5hA12/+uXypVKqRik1LPkYuAEw3enhIm6WjVoBfCzx+GNA1sxXKTVSKTUo8XgM8HbgjRLbtfOejH37APCC1tqpDMV5289Y938v8XgBL1kB/F1i9858oM2wTOMJSqnxyTgYpdQ84uPcsRtL4tq/AXZorX9kcZrvn0M5EwANc7vsnR8a5rd+2erDQNewAa9fhe4M8PsHeD/x9d3TQBPwbOL4RGBl4vE04rta6oHtxF32nvZBn9nBsZv4zM6xPhCPcXge2AOsBkYljs8F7k88vgrYmvgMtgJLHWo76z0B3wTem3hcDTwG7AU2ANMc/uzztf/dxN+8HngRuNDh9h8GjgC9ie/AUuDTwKcTzyvg54n+bSXH7joX+3C34TNYD1zlcPsLicc7vQ5sSfzc7PXnUK4/fmuY3/qVuLYvGua3ftnsQ7/WMNGv3D9SZkkQBEEQBCEA9MvlS0EQBEEQhHJDjDJBEARBEIQAIEaZIAiCIAhCABCjTBAEQRAEIQCIUSYIgiAIghAAxCgTBEEQBEEIAGKUCWWDUupFpdTixONvK6V+5nefBEEQ7CIaJuQjkGWWBMGCbwDfTNQCnEM827UgCEK5IBom5ESSxwplhVLqJWAocK3WuiNRqPhrwAit9Qf87Z0gCEJuRMOEXMjypVA2KKVmAROAiNa6A+KFirXWS/3tmSAIQn5Ew4R8iFEmlAWJIr3/AywBOpVSN/rcJUEQBNuIhgl2EKNMCDxKqSHAMuBftNY7gG8Rj80QBEEIPKJhgl0kpkwoa5RSo4HvAIuB+7XW3/W5S4IgCLYRDROMiFEmCIIgCIIQAGT5UhAEQRAEIQCIUSYIgiAIghAAxCgTBEEQBEEIAGKUCYIgCIIgBAAxygRBEARBEAKAGGWCIAiCIAgBQIwyQRAEQRCEACBGmSAIgiAIQgAQo0wQBEEQBCEA/H8ZEEhP9d6AVAAAAABJRU5ErkJggg==\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "### Out-of-Bag evaluation" ], "metadata": { "id": "9HiUsZa_VGBw" } }, { "cell_type": "markdown", "source": [ "It can be shown mathematically that only about 63% of the training instances are sampled on average for each predictor.⁠6 The remaining 37% of the training instances that are not sampled are called out-of-bag (oob) instances. Note that they are not the same 37% for all predictors. The following calculate this number when `m=1000`:" ], "metadata": { "id": "LXRxTOnAa2Ev" } }, { "cell_type": "code", "source": [ "print(1 - (1 - 1 / 1000) ** 1000)\n", "print(1 - np.exp(-1))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "t_pOXuBaVRwI", "outputId": "1104123d-7f8b-4160-f868-f6b17a2ee36c" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "0.6323045752290363\n", "0.6321205588285577\n" ] } ] }, { "cell_type": "markdown", "source": [ "In `Scikit-Learn`, you can set `oob_score=True` when creating a `BaggingClassifier` to request an automatic oob evaluation after training. The following code demonstrates this. The resulting evaluation score is available in the `oob_score_` attribute:" ], "metadata": { "id": "aMg1xzaMVHfr" } }, { "cell_type": "code", "source": [ "bag_clf = BaggingClassifier(DecisionTreeClassifier(), n_estimators=500,\n", " oob_score=True, n_jobs=-1, random_state=42)\n", "bag_clf.fit(X_train, y_train)\n", "bag_clf.oob_score_" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "MpOmKptvT65-", "outputId": "418d2dc7-8f3e-4379-cf07-be3a423772cb" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0.896" ] }, "metadata": {}, "execution_count": 22 } ] }, { "cell_type": "markdown", "source": [ "According to this oob evaluation, this `BaggingClassifier` is likely to achieve about 89.6% accuracy on the test set. Let’s verify this:" ], "metadata": { "id": "qjCSrZaaakSn" } }, { "cell_type": "code", "source": [ "y_pred = bag_clf.predict(X_test)\n", "accuracy_score(y_test, y_pred)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "C5GIYPd1an13", "outputId": "65ebf350-b3f7-4885-cd6b-3ef10aa70a76" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0.92" ] }, "metadata": {}, "execution_count": 27 } ] }, { "cell_type": "markdown", "source": [ "We get 92% accuracy on the test. The oob evaluation was a bit too pessimistic, a bit over 2% too low." ], "metadata": { "id": "OmiahqHWaqqo" } }, { "cell_type": "markdown", "source": [ "The `BaggingClassifier` class supports **sampling the features** as well. Sampling is controlled by two hyperparameters: `max_features` and `bootstrap_features`. They work the same way as `max_samples` and `bootstrap`, but for feature sampling instead of instance sampling. Thus, each predictor will be trained on a random subset of the input features.\n", "\n", "This technique is particularly useful when you are dealing with high-dimensional inputs (such as images). **Sampling both training instances and features is called the Random Patches method**.⁠ Keeping all training instances (by setting `bootstrap=False` and `max_samples=1.0`) but sampling features (by setting `bootstrap_features` to True and/or `max_features` to a value smaller than 1.0) is called the **Random Subspaces method**.⁠" ], "metadata": { "id": "rva-jGH6bOmw" } }, { "cell_type": "markdown", "source": [ "### Random forest" ], "metadata": { "id": "9oWyFDYpdIwf" } }, { "cell_type": "markdown", "source": [ "Random Forest9 is an ensemble of Decision Trees, generally trained via the bagging method (or sometimes pasting), **typically with `max_samples` set to the size of the training set.** Instead of building a `BaggingClassifier` and passing it a `DecisionTreeClassifier`, you can use the `RandomForestClassifier` class, which is more convenient and **optimized for Decision Trees** (similarly, there is a `RandomForestRegressor` class for regression tasks). The follwong `BaggingClassifier` is equivalent to random forest\n", "\n", "```python\n", "bag_clf = BaggingClassifier(\n", " DecisionTreeClassifier(max_features=\"sqrt\", max_leaf_nodes=16),\n", " n_estimators=500, n_jobs=-1, random_state=42)\n", "```\n", "\n", "The following code trains a Random Forest classifier with 500 trees, each limited to maximum 16 nodes, and using all available CPU cores:" ], "metadata": { "id": "j_TkqrLMdMT4" } }, { "cell_type": "code", "source": [ "rnd_clf = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, n_jobs=-1, random_state=42)\n", "rnd_clf.fit(X_train, y_train)\n", "y_pred_rf = rnd_clf.predict(X_test)" ], "metadata": { "id": "rBo1gB1MVWwI" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "y_pred = rnd_clf.predict(X_test)\n", "accuracy_score(y_test, y_pred)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "X5-UVNb5jk-H", "outputId": "63b8fb73-d95f-47f4-dcb5-fe0150c9e8d9" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0.912" ] }, "metadata": {}, "execution_count": 31 } ] }, { "cell_type": "markdown", "source": [ "You can also create an Extra-Trees classifier using `Scikit-Learn`’s `ExtraTreesClassifier` class. Its API is identical to the `RandomForestClassifier` class, except bootstrap defaults to False. Similarly, the `ExtraTreesRegressor` class has the same API as the RandomForestRegressor class, except bootstrap defaults to False." ], "metadata": { "id": "9x22GreAfOSv" } }, { "cell_type": "markdown", "source": [ "## AdaBoost" ], "metadata": { "id": "Ro3Mdc0UjuAe" } }, { "cell_type": "markdown", "source": [ "Scikit-Learn uses a multiclass version of AdaBoost called `SAMME`⁠ (which stands for Stagewise Additive Modeling using a Multiclass Exponential loss function). When there are just two classes, SAMME is equivalent to AdaBoost. If the predictors can estimate class probabilities (i.e., if they have a `predict_proba()` method), Scikit-Learn can use a variant of SAMME called SAMME.R (the R stands for “Real”), which relies on class probabilities rather than predictions and generally performs better." ], "metadata": { "id": "bS8rugGHkMov" } }, { "cell_type": "markdown", "source": [ "The following code trains an AdaBoost classifier based on 30 Decision Stumps using `Scikit-Learn`’s `AdaBoostClassifier` class (as you might expect, there is also an `AdaBoostRegressor` class). A Decision Stump is a Decision Tree with `max_depth=1`—in other words, **a tree composed of a single decision node** plus two leaf nodes. This is the default base estimator for the `AdaBoostClassifier` class:" ], "metadata": { "id": "Pmgz2OtNkX-n" } }, { "cell_type": "code", "source": [ "ada_clf = AdaBoostClassifier(\n", " DecisionTreeClassifier(max_depth=1), n_estimators=30,\n", " learning_rate=0.5, random_state=42)\n", "ada_clf.fit(X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "aDhLJhmhdfw2", "outputId": "7b365b79-8e1d-4ac6-ab4a-8dcd7433cf96" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "AdaBoostClassifier(base_estimator=DecisionTreeClassifier(max_depth=1),\n", " learning_rate=0.5, n_estimators=30, random_state=42)" ] }, "metadata": {}, "execution_count": 115 } ] }, { "cell_type": "code", "source": [ "plot_decision_boundary(ada_clf, X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 285 }, "id": "Gsh_380VkHX_", "outputId": "20d453fc-efc5-4ea5-c391-af74e94502fd" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "## Gradient Boosting" ], "metadata": { "id": "91HFYHBB-Bmv" } }, { "cell_type": "markdown", "source": [ "First, let’s generate a noisy quadratic dataset and fit a `DecisionTreeRegressor`to it:" ], "metadata": { "id": "2uM9bAyb-D1m" } }, { "cell_type": "code", "source": [ "np.random.seed(42)\n", "X = np.random.rand(100, 1) - 0.5\n", "y = 3 * X[:, 0] ** 2 + 0.05 * np.random.randn(100) # y = 3x² + Gaussian noise\n", "\n", "tree_reg1 = DecisionTreeRegressor(max_depth=2, random_state=42)\n", "tree_reg1.fit(X, y)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "LgoG2Cg58-oC", "outputId": "a702998b-7ece-466f-a438-3d2ada3b4f24" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "DecisionTreeRegressor(max_depth=2, random_state=42)" ] }, "metadata": {}, "execution_count": 119 } ] }, { "cell_type": "markdown", "source": [ "A simpler way to train GBRT ensembles is to use Scikit-Learn’s `GradientBoostingRegressor` class (there’s also a `GradientBoostingClassifier` class for classification). Much like the `RandomForestRegressor` class, it has hyperparameters to control the growth of Decision Trees (e.g., `max_depth`, `min_samples_leaf`), as well as hyperparameters to control the ensemble training, such as the number of trees (`n_estimator`s). " ], "metadata": { "id": "PXBmpTZ6-TUf" } }, { "cell_type": "code", "source": [ "gbrt = GradientBoostingRegressor(max_depth=2, n_estimators=3, learning_rate=1.0, random_state=42)\n", "gbrt.fit(X, y)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "QUJv2gs2-pmE", "outputId": "016aca12-5341-403d-ede4-03d9ddf357ad" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "GradientBoostingRegressor(learning_rate=1.0, max_depth=2, n_estimators=3,\n", " random_state=42)" ] }, "metadata": {}, "execution_count": 122 } ] }, { "cell_type": "markdown", "source": [ "The `learning_rate` hyperparameter scales the contribution of each tree. If you set it to a low value, such as 0.05, you will need more trees in the ensemble to fit the training set, but the predictions will usually generalize better. This is a regularization technique called shrinkage.\n", "\n", "To find the optimal number of trees, you could perform cross-validation using `GridSearchCV` or `RandomizedSearchCV`, as usual, but there’s a simpler way: if you set the `n_iter_no_change` hyperparameter to an integer value, say 10, then the `GradientBoostingRegressor` will automatically stop adding more trees during training if it sees that the last 10 trees didn’t help. This is simply early stopping, but with a little bit of patience: it tolerates having no progress for a few iterations before it stops. Let’s train the ensemble using early stopping:" ], "metadata": { "id": "HONBXa5P--iv" } }, { "cell_type": "code", "source": [ "gbrt_best = GradientBoostingRegressor(\n", " max_depth=2, learning_rate=0.05, n_estimators=500,\n", " n_iter_no_change=10, random_state=42)\n", "gbrt_best.fit(X, y)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "hSZK_Cvb-zke", "outputId": "c4b43dca-b453-4619-c547-b0bb44bb4c50" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "GradientBoostingRegressor(learning_rate=0.05, max_depth=2, n_estimators=500,\n", " n_iter_no_change=10, random_state=42)" ] }, "metadata": {}, "execution_count": 123 } ] }, { "cell_type": "markdown", "source": [ "If you set `n_iter_no_change` too low, training may stop too early and the model will underfit. But if you set it too high, it will overfit instead. We also set a fairly small learning rate and a high number of estimators, but the actual number of estimators in the trained ensemble is much lower, thanks to early stopping:" ], "metadata": { "id": "-JbdlvKh_hwO" } }, { "cell_type": "code", "source": [ "gbrt_best.n_estimators_" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "8zloEgk6_UJj", "outputId": "77810466-8ed3-4d26-848c-2faea98bc8b4" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "92" ] }, "metadata": {}, "execution_count": 124 } ] }, { "cell_type": "markdown", "source": [ "When `n_iter_no_change` is set, the `fit(`) method automatically splits the training set into a smaller training set and a validation set: this allows it to evaluate the model’s performance each time it adds a new tree. The size of the validation set is controlled by the `validation_fraction` hyperparameter, which is 10% by default. The tol hyperparameter determines the maximum performance improvement that still counts as negligible. It defaults to 0.0001." ], "metadata": { "id": "L-vULKsT_mEO" } }, { "cell_type": "markdown", "source": [ "The GradientBoostingRegressor class also supports a subsample hyperparameter, which specifies the fraction of training instances to be used for training each tree. For example, if `subsample=0.25`, then each tree is trained on 25% of the training instances, selected randomly. As you can probably guess by now, this technique trades a higher bias for a lower variance. It also speeds up training considerably. This is called **Stochastic Gradient Boosting**." ], "metadata": { "id": "E8JMjIRF_xdd" } }, { "cell_type": "markdown", "source": [ "## XGBoost" ], "metadata": { "id": "KHUBGzQqZRhM" } }, { "cell_type": "markdown", "source": [ "### Classification task" ], "metadata": { "id": "HIsGDU0-bB-a" } }, { "cell_type": "markdown", "source": [ "Here are the essential steps to build an XGBoost classification model in scikit-learn using cross-validation." ], "metadata": { "id": "l41vqfEkbKcK" } }, { "cell_type": "code", "source": [ "iris = datasets.load_iris()\n", "df = pd.DataFrame(data= np.c_[iris['data'], iris['target']],columns= iris['feature_names'] + ['target'])\n", "df.head()" ], "metadata": { "id": "ZVg6wzfA_Vyq", "colab": { "base_uri": "https://localhost:8080/", "height": 206 }, "outputId": "6a21e676-4e2b-44e6-f754-6b1c55ed0d58" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) \\\n", "0 5.1 3.5 1.4 0.2 \n", "1 4.9 3.0 1.4 0.2 \n", "2 4.7 3.2 1.3 0.2 \n", "3 4.6 3.1 1.5 0.2 \n", "4 5.0 3.6 1.4 0.2 \n", "\n", " target \n", "0 0.0 \n", "1 0.0 \n", "2 0.0 \n", "3 0.0 \n", "4 0.0 " ], "text/html": [ "\n", "
\n", "
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)target
05.13.51.40.20.0
14.93.01.40.20.0
24.73.21.30.20.0
34.63.11.50.20.0
45.03.61.40.20.0
\n", "
\n", " \n", " \n", " \n", "\n", " \n", "
\n", "
\n", " " ] }, "metadata": {}, "execution_count": 38 } ] }, { "cell_type": "code", "source": [ "X_train, X_test, y_train, y_test = train_test_split(iris['data'], iris['target'], random_state=42)" ], "metadata": { "id": "G3R0nCm-Z4ly" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "The following template is for building an XGBoost classifier" ], "metadata": { "id": "Q6wn7paXZpj-" } }, { "cell_type": "code", "source": [ "xgb = XGBClassifier(booster='gbtree', objective='multi:softprob', \n", " learning_rate=0.1, n_estimators=100, random_state=42, n_jobs=-1)" ], "metadata": { "id": "rsjJb0POZ8Y7" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "1. `booster='gbtree'`: The booster is the base learner. It's the machine learning model that is constructed during every round of boosting. You may have guessed that 'gbtree' stands for gradient boosted tree, the XGBoost default base learner. It's uncommon but possible to work with other base learners, \n", "\n", "2. `objective='multi:softprob'`: Standard options for the objective can be viewed in the XGBoost official documentation, https://xgboost.readthedocs.io/en/latest/parameter.html, under Learning Task Parameters. The multi:softprob objective is a standard alternative to binary:logistic when the dataset includes multiple classes. It computes the probabilities of classification and chooses the highest one. If not explicitly stated, XGBoost will often find the right objective for you.\n", "\n", "3. `max_depth=6`: The max_depth of a tree determines the number of branches each tree has. It's one of the most important hyperparameters in making balanced predictions. XGBoost uses a default of 6, unlike random forests, which don't provide a value unless explicitly programmed.\n", "\n", "3. `learning_rate=0.1`: Within XGBoost, this hyperparameter is often referred to as eta. This hyperparameter limits the variance by reducing the weight of each tree to the given percentage. \n", "\n", "4. `n_estimators=100`: Popular among ensemble methods, `n_estimators` is the number of boosted trees in the model. Increasing this number while decreasing `learning_rate` can lead to more robust results." ], "metadata": { "id": "rDCT_1p9aNBi" } }, { "cell_type": "code", "source": [ "xgb.fit(X_train, y_train)\n", "y_pred = xgb.predict(X_test)\n", "score = accuracy_score(y_pred, y_test)\n", "print('Score: ' + str(score))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "QYLOzVdMazA5", "outputId": "e270ed09-e3f4-4ade-d8df-cc3f1fd6433d" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Score: 1.0\n" ] } ] }, { "cell_type": "code", "source": [ "xgb.get_params()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Q8LM-RkUQLDd", "outputId": "cd49710a-45fa-4a2e-ce82-860b66c41fa0" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'base_score': 0.5,\n", " 'booster': 'gbtree',\n", " 'callbacks': None,\n", " 'colsample_bylevel': 1,\n", " 'colsample_bynode': 1,\n", " 'colsample_bytree': 1,\n", " 'early_stopping_rounds': None,\n", " 'enable_categorical': False,\n", " 'eval_metric': None,\n", " 'gamma': 0,\n", " 'gpu_id': -1,\n", " 'grow_policy': 'depthwise',\n", " 'importance_type': None,\n", " 'interaction_constraints': '',\n", " 'learning_rate': 0.1,\n", " 'max_bin': 256,\n", " 'max_cat_to_onehot': 4,\n", " 'max_delta_step': 0,\n", " 'max_depth': 6,\n", " 'max_leaves': 0,\n", " 'min_child_weight': 1,\n", " 'missing': nan,\n", " 'monotone_constraints': '()',\n", " 'n_estimators': 100,\n", " 'n_jobs': -1,\n", " 'num_parallel_tree': 1,\n", " 'objective': 'multi:softprob',\n", " 'predictor': 'auto',\n", " 'random_state': 42,\n", " 'reg_alpha': 0,\n", " 'reg_lambda': 1,\n", " 'sampling_method': 'uniform',\n", " 'scale_pos_weight': None,\n", " 'subsample': 1,\n", " 'tree_method': 'exact',\n", " 'use_label_encoder': False,\n", " 'validate_parameters': 1,\n", " 'verbosity': None}" ] }, "metadata": {}, "execution_count": 43 } ] }, { "cell_type": "markdown", "source": [ "### Regression task" ], "metadata": { "id": "e4LM00_-bExu" } }, { "cell_type": "markdown", "source": [ "Here are the essential steps to build an XGBoost regression model in scikit-learn using cross-validation." ], "metadata": { "id": "7uFOM-SqbIZ6" } }, { "cell_type": "code", "source": [ "X,y = datasets.load_diabetes(return_X_y=True)\n", "\n", "xgb = XGBRegressor(booster='gbtree', objective='reg:squarederror', \n", " learning_rate=0.1, n_estimators=100, random_state=42, n_jobs=-1)\n", "\n", "scores = cross_val_score(xgb, X, y, scoring='neg_mean_squared_error', cv=5)\n", "\n", "# Take square root of the scores\n", "rmse = np.sqrt(-scores)\n", "\n", "# Display accuracy\n", "print('RMSE:', np.round(rmse, 3))\n", "\n", "# Display mean score\n", "print('RMSE mean: %0.3f' % (rmse.mean()))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "q5w9Jclca8Gs", "outputId": "7d67260e-3a04-4ba2-84f6-b95dc8227cf1" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "RMSE: [63.033 59.689 64.538 63.699 64.661]\n", "RMSE mean: 63.124\n" ] } ] }, { "cell_type": "code", "source": [ "xgb.fit(X,y)\n", "xgb.get_params()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "CbihBstGRQom", "outputId": "ce8ceff2-0207-4fac-e3c4-050b039028ad" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'base_score': 0.5,\n", " 'booster': 'gbtree',\n", " 'callbacks': None,\n", " 'colsample_bylevel': 1,\n", " 'colsample_bynode': 1,\n", " 'colsample_bytree': 1,\n", " 'early_stopping_rounds': None,\n", " 'enable_categorical': False,\n", " 'eval_metric': None,\n", " 'gamma': 0,\n", " 'gpu_id': -1,\n", " 'grow_policy': 'depthwise',\n", " 'importance_type': None,\n", " 'interaction_constraints': '',\n", " 'learning_rate': 0.1,\n", " 'max_bin': 256,\n", " 'max_cat_to_onehot': 4,\n", " 'max_delta_step': 0,\n", " 'max_depth': 6,\n", " 'max_leaves': 0,\n", " 'min_child_weight': 1,\n", " 'missing': nan,\n", " 'monotone_constraints': '()',\n", " 'n_estimators': 100,\n", " 'n_jobs': -1,\n", " 'num_parallel_tree': 1,\n", " 'objective': 'reg:squarederror',\n", " 'predictor': 'auto',\n", " 'random_state': 42,\n", " 'reg_alpha': 0,\n", " 'reg_lambda': 1,\n", " 'sampling_method': 'uniform',\n", " 'scale_pos_weight': 1,\n", " 'subsample': 1,\n", " 'tree_method': 'exact',\n", " 'validate_parameters': 1,\n", " 'verbosity': None}" ] }, "metadata": {}, "execution_count": 50 } ] }, { "cell_type": "markdown", "source": [ "Without a baseline of comparison, we have no idea what that score means. Converting the target column, `y`, into a pandas DataFrame with the `.describe()` method will give the quartiles and the general statistics of the predictor column, as follows:" ], "metadata": { "id": "HAY1SjZxboMz" } }, { "cell_type": "code", "source": [ "pd.DataFrame(y).describe()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 300 }, "id": "F35eRsafbXnV", "outputId": "93fd4504-2aba-439f-e9b1-d85ed4f768fb" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " 0\n", "count 442.000000\n", "mean 152.133484\n", "std 77.093005\n", "min 25.000000\n", "25% 87.000000\n", "50% 140.500000\n", "75% 211.500000\n", "max 346.000000" ], "text/html": [ "\n", "
\n", "
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0
count442.000000
mean152.133484
std77.093005
min25.000000
25%87.000000
50%140.500000
75%211.500000
max346.000000
\n", "
\n", " \n", " \n", " \n", "\n", " \n", "
\n", "
\n", " " ] }, "metadata": {}, "execution_count": 49 } ] }, { "cell_type": "markdown", "source": [ "A score of 63.124 is less than 1 standard deviation, a respectable result." ], "metadata": { "id": "gqIRc8v6bubr" } }, { "cell_type": "markdown", "source": [ "### Speed comparsion" ], "metadata": { "id": "FLDE-3-RfD4c" } }, { "cell_type": "markdown", "source": [ "Let's now compare `GradientBoostingClassifier` and `XGBoostClassifier` with the [exoplanet dataset](https://www.kaggle.com/datasets/keplersmachines/kepler-labelled-time-series-data) for its speed " ], "metadata": { "id": "vKnuqcvafF1c" } }, { "cell_type": "code", "source": [ "!wget https://github.com/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/raw/master/Chapter04/exoplanets.csv" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "YLKF2oiTbtbn", "outputId": "f23977cc-bfed-44af-ffe2-48f5252e0b51" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "--2022-05-21 11:00:29-- https://github.com/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/raw/master/Chapter04/exoplanets.csv\n", "Resolving github.com (github.com)... 140.82.114.4\n", "Connecting to github.com (github.com)|140.82.114.4|:443... connected.\n", "HTTP request sent, awaiting response... 302 Found\n", "Location: https://media.githubusercontent.com/media/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/master/Chapter04/exoplanets.csv [following]\n", "--2022-05-21 11:00:29-- https://media.githubusercontent.com/media/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/master/Chapter04/exoplanets.csv\n", "Resolving media.githubusercontent.com (media.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", "Connecting to media.githubusercontent.com (media.githubusercontent.com)|185.199.108.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 262223348 (250M) [text/plain]\n", "Saving to: ‘exoplanets.csv’\n", "\n", "exoplanets.csv 100%[===================>] 250.08M 193MB/s in 1.3s \n", "\n", "2022-05-21 11:00:34 (193 MB/s) - ‘exoplanets.csv’ saved [262223348/262223348]\n", "\n" ] } ] }, { "cell_type": "code", "source": [ "df = pd.read_csv('exoplanets.csv')\n", "df.head()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 300 }, "id": "PqwtKb68dZi7", "outputId": "c02e13ce-5922-46c1-bea3-86fe790b8a16" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " LABEL FLUX.1 FLUX.2 FLUX.3 FLUX.4 FLUX.5 FLUX.6 FLUX.7 \\\n", "0 2 93.85 83.81 20.10 -26.98 -39.56 -124.71 -135.18 \n", "1 2 -38.88 -33.83 -58.54 -40.09 -79.31 -72.81 -86.55 \n", "2 2 532.64 535.92 513.73 496.92 456.45 466.00 464.50 \n", "3 2 326.52 347.39 302.35 298.13 317.74 312.70 322.33 \n", "4 2 -1107.21 -1112.59 -1118.95 -1095.10 -1057.55 -1034.48 -998.34 \n", "\n", " FLUX.8 FLUX.9 ... FLUX.3188 FLUX.3189 FLUX.3190 FLUX.3191 \\\n", "0 -96.27 -79.89 ... -78.07 -102.15 -102.15 25.13 \n", "1 -85.33 -83.97 ... -3.28 -32.21 -32.21 -24.89 \n", "2 486.39 436.56 ... -71.69 13.31 13.31 -29.89 \n", "3 311.31 312.42 ... 5.71 -3.73 -3.73 30.05 \n", "4 -1022.71 -989.57 ... -594.37 -401.66 -401.66 -357.24 \n", "\n", " FLUX.3192 FLUX.3193 FLUX.3194 FLUX.3195 FLUX.3196 FLUX.3197 \n", "0 48.57 92.54 39.32 61.42 5.08 -39.54 \n", "1 -4.86 0.76 -11.70 6.46 16.00 19.93 \n", "2 -20.88 5.06 -11.80 -28.91 -70.02 -96.67 \n", "3 20.03 -12.67 -8.77 -17.31 -17.35 13.98 \n", "4 -443.76 -438.54 -399.71 -384.65 -411.79 -510.54 \n", "\n", "[5 rows x 3198 columns]" ], "text/html": [ "\n", "
\n", "
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
LABELFLUX.1FLUX.2FLUX.3FLUX.4FLUX.5FLUX.6FLUX.7FLUX.8FLUX.9...FLUX.3188FLUX.3189FLUX.3190FLUX.3191FLUX.3192FLUX.3193FLUX.3194FLUX.3195FLUX.3196FLUX.3197
0293.8583.8120.10-26.98-39.56-124.71-135.18-96.27-79.89...-78.07-102.15-102.1525.1348.5792.5439.3261.425.08-39.54
12-38.88-33.83-58.54-40.09-79.31-72.81-86.55-85.33-83.97...-3.28-32.21-32.21-24.89-4.860.76-11.706.4616.0019.93
22532.64535.92513.73496.92456.45466.00464.50486.39436.56...-71.6913.3113.31-29.89-20.885.06-11.80-28.91-70.02-96.67
32326.52347.39302.35298.13317.74312.70322.33311.31312.42...5.71-3.73-3.7330.0520.03-12.67-8.77-17.31-17.3513.98
42-1107.21-1112.59-1118.95-1095.10-1057.55-1034.48-998.34-1022.71-989.57...-594.37-401.66-401.66-357.24-443.76-438.54-399.71-384.65-411.79-510.54
\n", "

5 rows × 3198 columns

\n", "
\n", " \n", " \n", " \n", "\n", " \n", "
\n", "
\n", " " ] }, "metadata": {}, "execution_count": 51 } ] }, { "cell_type": "code", "source": [ "# Split data into X and y\n", "X = df.iloc[:,1:]\n", "y = df.iloc[:,0]\n", "\n", "# Split data into train and test sets\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=2)" ], "metadata": { "id": "NiW1d_VCdk7t" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "start = time.time()\n", "\n", "gbr = GradientBoostingClassifier(n_estimators=100, max_depth=2, random_state=42)\n", "gbr.fit(X_train, y_train)\n", "y_pred = gbr.predict(X_test)\n", "score = accuracy_score(y_pred, y_test)\n", "print('Score: ' + str(score))\n", "\n", "end = time.time()\n", "elapsed = end - start\n", "\n", "print('Run Time: ' + str(elapsed) + ' seconds')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1Oslw4JXer5J", "outputId": "44836778-7c2a-4e79-e1a9-c240a978c260" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Score: 0.9874213836477987\n", "Run Time: 248.6392641067505 seconds\n" ] } ] }, { "cell_type": "code", "source": [ "start = time.time()\n", "\n", "# Instantiate the XGBRegressor, xg_reg\n", "xg_reg = XGBClassifier(n_estimators=100, max_depth=2, random_state=42)\n", "\n", "# class column has to start from 0 (as required since version 1.3.2).\n", "le = LabelEncoder()\n", "y_train = le.fit_transform(y_train)\n", "y_test = le.fit_transform(y_test)\n", "# Fit xg_reg to training set\n", "xg_reg.fit(X_train, y_train)\n", "\n", "# Predict labels of test set, y_pred\n", "y_pred = xg_reg.predict(X_test)\n", "\n", "score = accuracy_score(y_pred, y_test)\n", "\n", "print('Score: ' + str(score))\n", "\n", "end = time.time()\n", "elapsed = end - start\n", "\n", "print('Run Time: ' + str(elapsed) + ' seconds')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "KWi-TIeee2BU", "outputId": "9c05b685-c9ee-4502-b4af-b405459c22b4" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Score: 0.9913522012578616\n", "Run Time: 52.40076756477356 seconds\n" ] } ] }, { "cell_type": "markdown", "source": [ "When it comes to big data, an algorithm six as fast can save weeks or months of computational time and resources! This advantage is huge in the world of big data. In the world of boosting, XGBoost is the model of choice due to its unparalleled speed and impressive accuracy." ], "metadata": { "id": "jmX7g10ofdRD" } }, { "cell_type": "markdown", "source": [ "### Hyperparameter" ], "metadata": { "id": "AT6OUUregRfk" } }, { "cell_type": "markdown", "source": [ "XGBoost has many hyperparameters. XGBoost base learner hyperparameters incorporate all decision tree hyperparameters as a starting point. There are gradient boosting hyperparameters, since XGBoost is an enhanced version of gradient boosting." ], "metadata": { "id": "_YB4388QgiQr" } }, { "cell_type": "code", "source": [ "!wget https://github.com/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/raw/master/Chapter06/heart_disease.csv" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "H-GTv5RtffvG", "outputId": "2c48abfd-5517-41c8-fe37-188b1b2b059d" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "--2022-05-21 05:49:41-- https://github.com/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/raw/master/Chapter06/heart_disease.csv\n", "Resolving github.com (github.com)... 140.82.121.3\n", "Connecting to github.com (github.com)|140.82.121.3|:443... connected.\n", "HTTP request sent, awaiting response... 302 Found\n", "Location: https://media.githubusercontent.com/media/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/master/Chapter06/heart_disease.csv [following]\n", "--2022-05-21 05:49:41-- https://media.githubusercontent.com/media/PacktPublishing/Hands-On-Gradient-Boosting-with-XGBoost-and-Scikit-learn/master/Chapter06/heart_disease.csv\n", "Resolving media.githubusercontent.com (media.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", "Connecting to media.githubusercontent.com (media.githubusercontent.com)|185.199.108.133|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 11328 (11K) [text/plain]\n", "Saving to: ‘heart_disease.csv.1’\n", "\n", "heart_disease.csv.1 100%[===================>] 11.06K --.-KB/s in 0s \n", "\n", "2022-05-21 05:49:41 (101 MB/s) - ‘heart_disease.csv.1’ saved [11328/11328]\n", "\n" ] } ] }, { "cell_type": "code", "source": [ "df = pd.read_csv('heart_disease.csv')\n", "df.head()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 206 }, "id": "Q6qyxyV5guIL", "outputId": "59a4af8c-697f-4897-eab8-7ee096d3bae1" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ " age sex cp trestbps chol fbs restecg thalach exang oldpeak slope \\\n", "0 63 1 3 145 233 1 0 150 0 2.3 0 \n", "1 37 1 2 130 250 0 1 187 0 3.5 0 \n", "2 41 0 1 130 204 0 0 172 0 1.4 2 \n", "3 56 1 1 120 236 0 1 178 0 0.8 2 \n", "4 57 0 0 120 354 0 1 163 1 0.6 2 \n", "\n", " ca thal target \n", "0 0 1 1 \n", "1 0 2 1 \n", "2 0 2 1 \n", "3 0 2 1 \n", "4 0 2 1 " ], "text/html": [ "\n", "
\n", "
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
agesexcptrestbpscholfbsrestecgthalachexangoldpeakslopecathaltarget
063131452331015002.30011
137121302500118703.50021
241011302040017201.42021
356111202360117800.82021
457001203540116310.62021
\n", "
\n", " \n", " \n", " \n", "\n", " \n", "
\n", "
\n", " " ] }, "metadata": {}, "execution_count": 58 } ] }, { "cell_type": "code", "source": [ "# Split data into X and y\n", "X = df.iloc[:, :-1]\n", "y = df.iloc[:, -1]" ], "metadata": { "id": "161dPMyKgx8q" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "Before tuning hyperparameters, let's build a classifier so that we can obtain a baseline score as a starting point." ], "metadata": { "id": "7H3mCXj8hItV" } }, { "cell_type": "markdown", "source": [ "When fine-tuning hyperparameters, GridSearchCV and RandomizedSearchCV are the standard options. However, `cross_val_score` and `GridSearchCV/RandomizedSearchCV` do not split data the same way. One solution is to use `StratifiedKFold` whenever cross-validation is used.\n", "\n", "A stratified fold includes the same percentage of target values in each fold. If a dataset contains 60% 1s and 40% 0s in the target column, each stratified test set contains 60% 1s and 40% 0s. When folds are random, it's possible that one test set contains a 70-30 split while another contains a 50-50 split of target values." ], "metadata": { "id": "_sr6Y00Zhsyr" } }, { "cell_type": "code", "source": [ "kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)" ], "metadata": { "id": "iZzwJoOFiM4V" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "# The 'binary:logistic' objective is standard for binary classification in determining the loss function\n", "model = XGBClassifier(booster='gbtree', objective='binary:logistic', random_state=42)\n", "# Obtain scores of cross-validation\n", "scores = cross_val_score(model, X, y, cv=kfold)\n", "\n", "# Display accuracy\n", "print('Accuracy:', np.round(scores, 2))\n", "\n", "# Display mean accuracy\n", "print('Accuracy mean: %0.2f' % (scores.mean()))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "-IHX7FVVg_DM", "outputId": "9079ca1c-719f-42cf-bb3a-f4bd92254fce" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Accuracy: [0.85 0.72 0.74 0.82 0.78]\n", "Accuracy mean: 0.78\n" ] } ] }, { "cell_type": "markdown", "source": [ "The point here is to use the same folds to obtain new scores when fine-tuning hyperparameters with GridSearchCV and RandomizedSearchCV so that the comparison of scores is fair." ], "metadata": { "id": "fl1AJZVFiacl" } }, { "cell_type": "code", "source": [ "def grid_search(params, random=False): \n", " \n", " xgb = XGBClassifier(booster='gbtree', objective='binary:logistic', random_state=42)\n", " \n", " kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n", " \n", " if random:\n", " grid = RandomizedSearchCV(xgb, params, cv=kfold, n_iter=20, n_jobs=-1, random_state=42)\n", " else:\n", " # Instantiate GridSearchCV as grid_reg\n", " grid = GridSearchCV(xgb, params, cv=kfold, n_jobs=-1)\n", " \n", " # Fit grid_reg on X_train and y_train\n", " grid.fit(X, y)\n", "\n", " # Extract best params\n", " best_params = grid.best_params_\n", "\n", " # Print best params\n", " print(\"Best params:\", best_params)\n", " \n", " # Compute best score\n", " best_score = grid.best_score_\n", "\n", " # Print best score\n", " print(\"Best score: {:.5f}\".format(best_score))" ], "metadata": { "id": "hirVfvYGimTz" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "The XGBoost hyperparameters presented here are not meant to be exhaustive, but they are meant to be comprehensive. For a complete list of hyperparameters, read the official documentation, XGBoost Parameters, at https://xgboost.readthedocs.io/en/latest/parameter.html." ], "metadata": { "id": "FL9tTjDViy0U" } }, { "cell_type": "markdown", "source": [ "#### learning_rate" ], "metadata": { "id": "C5vqCuCyjgvc" } }, { "cell_type": "markdown", "source": [ "`learning_rate` shrinks the weights of trees for each round of boosting. By lowering `learning_rate`, more trees are required to produce better scores. Lowering `learning_rate` prevents overfitting because the size of the weights carried forward is smaller.\n", "\n", "A default value of 0.3 is used. Here is a starting range for `learning_rate` as placed inside our grid_search function:" ], "metadata": { "id": "9XT4L0KzjjVd" } }, { "cell_type": "code", "source": [ "grid_search(params={'learning_rate':[0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5]})" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "-Gte23anjEJL", "outputId": "3a126484-69f4-4d5a-d987-37a98f755acb" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Best params: {'learning_rate': 0.5}\n", "Best score: 0.80525\n" ] } ] }, { "cell_type": "markdown", "source": [ "lowering `learning_rate` may be advantageous when `n_estimators` goes up." ], "metadata": { "id": "bOJ9FRG8kidc" } }, { "cell_type": "markdown", "source": [ "#### max_depth" ], "metadata": { "id": "y7l7T2CNkSs0" } }, { "cell_type": "markdown", "source": [ "`max_depth` determines the length of the tree, equivalent to the number of rounds of splitting. Limiting `max_depth` prevents overfitting because the individual trees can only grow as far as `max_depth` allows. XGBoost provides a default `max_depth` value of six:" ], "metadata": { "id": "45DQQ5BUkVCk" } }, { "cell_type": "code", "source": [ "grid_search(params={'max_depth':[2, 3, 5, 6, 8]})" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "yAjw3wKmjxRH", "outputId": "faa0934a-b667-46ed-b5ae-7d5417fbc051" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Best params: {'max_depth': 2}\n", "Best score: 0.79552\n" ] } ] }, { "cell_type": "markdown", "source": [ "Changing `max_depth` from 6 to 2 gave a better score. The lower value for `max_depth` means variance has been reduced." ], "metadata": { "id": "L4Yw25h0kd_m" } }, { "cell_type": "markdown", "source": [ "#### gamma" ], "metadata": { "id": "Y8K3Shxwkm80" } }, { "cell_type": "markdown", "source": [ "Known as a Lagrange multiplier, `gamma` provides a threshold that nodes must surpass before making further splits according to the loss function. There is no upper limit to the value of `gamma`. The default is 0, and anything over 10 is considered very high. Increasing `gamma` results in a more conservative model:" ], "metadata": { "id": "I7oV3JtKkoK0" } }, { "cell_type": "code", "source": [ "grid_search(params={'gamma':[0, 0.01, 0.1, 0.5, 1, 2]})" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3q-MZjFLkaMz", "outputId": "18e0426b-b9da-4e98-b015-3188f8d35e50" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Best params: {'gamma': 1}\n", "Best score: 0.79880\n" ] } ] }, { "cell_type": "markdown", "source": [ "Changing gamma from 0 to 1 has resulted in a slight improvement." ], "metadata": { "id": "LlAtNDfuk4Yr" } }, { "cell_type": "markdown", "source": [ "#### min_child_weight" ], "metadata": { "id": "PE8jqb3lk7kb" } }, { "cell_type": "markdown", "source": [ "`min_child_weight` refers to the minimum sum of weights required for a node to split into a child. If the sum of the weights is less than the value of `min_child_weight`, no further splits are made. `min_child_weight` reduces overfitting by increasing its value:" ], "metadata": { "id": "H9m98Cg9k84E" } }, { "cell_type": "code", "source": [ "grid_search(params={'min_child_weight':[1, 2, 3, 4, 5]})" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "FXgP8k9pkyMG", "outputId": "31488e96-01c4-4c94-9a9b-af13fc07c6f8" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Best params: {'min_child_weight': 5}\n", "Best score: 0.81202\n" ] } ] }, { "cell_type": "markdown", "source": [ "A slight adjustment to `min_child_weight` form 1 to 5 gives the best results yet." ], "metadata": { "id": "_Uj4v6NclNTk" } }, { "cell_type": "markdown", "source": [ "#### subsample" ], "metadata": { "id": "lpUThvNwlYR0" } }, { "cell_type": "markdown", "source": [ "The `subsample` hyperparameter limits the percentage of training instances (rows) for each boosting round. Decreasing `subsample` from 100% reduces overfitting:" ], "metadata": { "id": "0IbGAEDvlaEE" } }, { "cell_type": "code", "source": [ "grid_search(params={'subsample':[0.5, 0.7, 0.8, 0.9, 1]})" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "BZmXj7R8lFqH", "outputId": "fa57581a-ec6d-42e4-8310-87b1f56a5ca8" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Best params: {'subsample': 0.5}\n", "Best score: 0.82525\n" ] } ] }, { "cell_type": "markdown", "source": [ "The score has improved by a slight amount once again, indicating a small presence of overfitting." ], "metadata": { "id": "oT8tJABxlkLt" } }, { "cell_type": "markdown", "source": [ "#### colsample_bytree" ], "metadata": { "id": "STS11E58lpS-" } }, { "cell_type": "markdown", "source": [ "Similar to `subsample`, `colsample_bytree` randomly selects particular columns according to the given percentage. `colsample_bytree` is useful for limiting the influence of columns and reducing variance. Note that `colsample_bytree` takes a percentage as input, not the number of columns:" ], "metadata": { "id": "3k5abqx8lq_F" } }, { "cell_type": "code", "source": [ "grid_search(params={'colsample_bytree':[0.5, 0.7, 0.8, 0.9, 1]})" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "02a7625clgR7", "outputId": "a9d61e46-da14-47ce-cf48-af670272c8aa" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Best params: {'colsample_bytree': 0.5}\n", "Best score: 0.79874\n" ] } ] }, { "cell_type": "markdown", "source": [ "You are encouraged to try `colsample_bylevel` and `colsample_bynode` on your own. `colsample_bylevel` randomly selects columns for each tree depth, and `colsample_bynode` randomly selects columns when evaluating each tree split." ], "metadata": { "id": "C-6xeLBMl9nt" } }, { "cell_type": "markdown", "source": [ "#### n_estimators" ], "metadata": { "id": "5ISk5sini444" } }, { "cell_type": "markdown", "source": [ "Recall that `n_estimators` provides the number of trees in the ensemble. In the case of XGBoost, `n_estimators` is the number of trees trained on the residuals. Initialize a grid search of `n_estimators` with the default of 100, then double the number of trees through 800 as follows:" ], "metadata": { "id": "QbeWxPWei76T" } }, { "cell_type": "code", "source": [ "grid_search(params={'n_estimators':[100, 200, 400, 800]})" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "djxGbftfhKm8", "outputId": "a420b09b-6e7a-4552-cd6f-f9cf58adbe15" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Best params: {'n_estimators': 200}\n", "Best score: 0.79219\n" ] } ] }, { "cell_type": "markdown", "source": [ "Since our dataset is small, increasing `n_estimators` did not produce better results." ], "metadata": { "id": "QYDz9YREjcLO" } }, { "cell_type": "markdown", "source": [ "#### Applying early stopping" ], "metadata": { "id": "s42ccMKbmDLF" } }, { "cell_type": "markdown", "source": [ "`early_stopping_rounds` is not a hyperparameter, but a strategy for optimizing the `n_estimators` hyperparameter.\n", "\n", "Normally when choosing hyperparameters, a test score is given after all boosting rounds are complete. To use early stopping, we need a test score after each round. `eval_metric` and `eval_set` may be used as parameters for `.fit` to generate test scores for each training round. `eval_metric` provides the scoring method, commonly 'error' for classification, and 'rmse' for regression. `eval_set` provides the test to be evaluated, commonly X_test and y_test." ], "metadata": { "id": "_f41kkk0mPil" } }, { "cell_type": "markdown", "source": [ "The following steps display an evaluation metric for each round of training with the default `n_estimators=100:`" ], "metadata": { "id": "b_ND_pUUm9md" } }, { "cell_type": "code", "source": [ "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)\n", "model = XGBClassifier(booster='gbtree', objective='binary:logistic', random_state=42)\n", "eval_set = [(X_test, y_test)]\n", "eval_metric='error'\n", "model.fit(X_train, y_train, eval_metric=eval_metric, eval_set=eval_set)\n", "# make predictions for test data\n", "y_pred = model.predict(X_test)\n", "# evaluate predictions\n", "accuracy = accuracy_score(y_test, y_pred)\n", "print(\"Accuracy: %.2f%%\" % (accuracy * 100.0))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "yUgNVaUJl10d", "outputId": "d8d452c7-7fa7-4679-c98c-e04efbb02ada" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "[0]\tvalidation_0-error:0.23684\n", "[1]\tvalidation_0-error:0.22368\n", "[2]\tvalidation_0-error:0.22368\n", "[3]\tvalidation_0-error:0.21053\n", "[4]\tvalidation_0-error:0.22368\n", "[5]\tvalidation_0-error:0.18421\n", "[6]\tvalidation_0-error:0.21053\n", "[7]\tvalidation_0-error:0.22368\n", "[8]\tvalidation_0-error:0.19737\n", "[9]\tvalidation_0-error:0.19737\n", "[10]\tvalidation_0-error:0.18421\n", "[11]\tvalidation_0-error:0.18421\n", "[12]\tvalidation_0-error:0.19737\n", "[13]\tvalidation_0-error:0.17105\n", "[14]\tvalidation_0-error:0.18421\n", "[15]\tvalidation_0-error:0.18421\n", "[16]\tvalidation_0-error:0.18421\n", "[17]\tvalidation_0-error:0.18421\n", "[18]\tvalidation_0-error:0.18421\n", "[19]\tvalidation_0-error:0.19737\n", "[20]\tvalidation_0-error:0.18421\n", "[21]\tvalidation_0-error:0.18421\n", "[22]\tvalidation_0-error:0.18421\n", "[23]\tvalidation_0-error:0.18421\n", "[24]\tvalidation_0-error:0.18421\n", "[25]\tvalidation_0-error:0.18421\n", "[26]\tvalidation_0-error:0.18421\n", "[27]\tvalidation_0-error:0.18421\n", "[28]\tvalidation_0-error:0.18421\n", "[29]\tvalidation_0-error:0.18421\n", "[30]\tvalidation_0-error:0.18421\n", "[31]\tvalidation_0-error:0.17105\n", "[32]\tvalidation_0-error:0.18421\n", "[33]\tvalidation_0-error:0.18421\n", "[34]\tvalidation_0-error:0.18421\n", "[35]\tvalidation_0-error:0.17105\n", "[36]\tvalidation_0-error:0.17105\n", "[37]\tvalidation_0-error:0.17105\n", "[38]\tvalidation_0-error:0.18421\n", "[39]\tvalidation_0-error:0.17105\n", "[40]\tvalidation_0-error:0.18421\n", "[41]\tvalidation_0-error:0.18421\n", "[42]\tvalidation_0-error:0.18421\n", "[43]\tvalidation_0-error:0.18421\n", "[44]\tvalidation_0-error:0.18421\n", "[45]\tvalidation_0-error:0.18421\n", "[46]\tvalidation_0-error:0.18421\n", "[47]\tvalidation_0-error:0.18421\n", "[48]\tvalidation_0-error:0.18421\n", "[49]\tvalidation_0-error:0.18421\n", "[50]\tvalidation_0-error:0.18421\n", "[51]\tvalidation_0-error:0.18421\n", "[52]\tvalidation_0-error:0.18421\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.7/dist-packages/xgboost/sklearn.py:797: UserWarning: `eval_metric` in `fit` method is deprecated for better compatibility with scikit-learn, use `eval_metric` in constructor or`set_params` instead.\n", " UserWarning,\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "[53]\tvalidation_0-error:0.18421\n", "[54]\tvalidation_0-error:0.18421\n", "[55]\tvalidation_0-error:0.18421\n", "[56]\tvalidation_0-error:0.18421\n", "[57]\tvalidation_0-error:0.18421\n", "[58]\tvalidation_0-error:0.18421\n", "[59]\tvalidation_0-error:0.18421\n", "[60]\tvalidation_0-error:0.18421\n", "[61]\tvalidation_0-error:0.18421\n", "[62]\tvalidation_0-error:0.18421\n", "[63]\tvalidation_0-error:0.18421\n", "[64]\tvalidation_0-error:0.18421\n", "[65]\tvalidation_0-error:0.18421\n", "[66]\tvalidation_0-error:0.18421\n", "[67]\tvalidation_0-error:0.18421\n", "[68]\tvalidation_0-error:0.18421\n", "[69]\tvalidation_0-error:0.18421\n", "[70]\tvalidation_0-error:0.18421\n", "[71]\tvalidation_0-error:0.18421\n", "[72]\tvalidation_0-error:0.18421\n", "[73]\tvalidation_0-error:0.18421\n", "[74]\tvalidation_0-error:0.18421\n", "[75]\tvalidation_0-error:0.18421\n", "[76]\tvalidation_0-error:0.18421\n", "[77]\tvalidation_0-error:0.18421\n", "[78]\tvalidation_0-error:0.18421\n", "[79]\tvalidation_0-error:0.18421\n", "[80]\tvalidation_0-error:0.18421\n", "[81]\tvalidation_0-error:0.18421\n", "[82]\tvalidation_0-error:0.18421\n", "[83]\tvalidation_0-error:0.18421\n", "[84]\tvalidation_0-error:0.18421\n", "[85]\tvalidation_0-error:0.18421\n", "[86]\tvalidation_0-error:0.18421\n", "[87]\tvalidation_0-error:0.18421\n", "[88]\tvalidation_0-error:0.18421\n", "[89]\tvalidation_0-error:0.18421\n", "[90]\tvalidation_0-error:0.18421\n", "[91]\tvalidation_0-error:0.18421\n", "[92]\tvalidation_0-error:0.18421\n", "[93]\tvalidation_0-error:0.18421\n", "[94]\tvalidation_0-error:0.18421\n", "[95]\tvalidation_0-error:0.18421\n", "[96]\tvalidation_0-error:0.18421\n", "[97]\tvalidation_0-error:0.18421\n", "[98]\tvalidation_0-error:0.18421\n", "[99]\tvalidation_0-error:0.18421\n", "Accuracy: 81.58%\n" ] } ] }, { "cell_type": "markdown", "source": [ "We know that `StratifiedKFold` cross-validation gives a mean accuracy of 78% when n_estimators=100. The disparity in scores comes from the difference in test sets." ], "metadata": { "id": "YUYIc8cvm3X1" } }, { "cell_type": "markdown", "source": [ "#### early_stopping_rounds" ], "metadata": { "id": "rHYUq8m-nCed" } }, { "cell_type": "markdown", "source": [ "`early_stopping_rounds` is an optional parameter to include with `eval_metric` and `eval_set` when fitting a model. Let's try `early_stopping_rounds=10`.\n", "The previous code is repeated with `early_stopping_rounds=10` added in:" ], "metadata": { "id": "rbV-EIxdnD3F" } }, { "cell_type": "code", "source": [ "model = XGBClassifier(booster='gbtree', objective='binary:logistic', random_state=42)\n", "eval_set = [(X_test, y_test)]\n", "eval_metric=\"error\"\n", "model.fit(X_train, y_train, eval_metric=eval_metric, eval_set=eval_set, early_stopping_rounds=10, verbose=True)\n", "y_pred = model.predict(X_test)\n", "accuracy = accuracy_score(y_test, y_pred)\n", "print(\"Accuracy: %.2f%%\" % (accuracy * 100.0))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "S-8zyAq5nQQN", "outputId": "87c02e94-59b9-4db7-e953-0654af1f16c4" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "[0]\tvalidation_0-error:0.23684\n", "[1]\tvalidation_0-error:0.22368\n", "[2]\tvalidation_0-error:0.22368\n", "[3]\tvalidation_0-error:0.21053\n", "[4]\tvalidation_0-error:0.22368\n", "[5]\tvalidation_0-error:0.18421\n", "[6]\tvalidation_0-error:0.21053\n", "[7]\tvalidation_0-error:0.22368\n", "[8]\tvalidation_0-error:0.19737\n", "[9]\tvalidation_0-error:0.19737\n", "[10]\tvalidation_0-error:0.18421\n", "[11]\tvalidation_0-error:0.18421\n", "[12]\tvalidation_0-error:0.19737\n", "[13]\tvalidation_0-error:0.17105\n", "[14]\tvalidation_0-error:0.18421\n", "[15]\tvalidation_0-error:0.18421\n", "[16]\tvalidation_0-error:0.18421\n", "[17]\tvalidation_0-error:0.18421\n", "[18]\tvalidation_0-error:0.18421\n", "[19]\tvalidation_0-error:0.19737\n", "[20]\tvalidation_0-error:0.18421\n", "[21]\tvalidation_0-error:0.18421\n", "[22]\tvalidation_0-error:0.18421\n", "Accuracy: 82.89%\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.7/dist-packages/xgboost/sklearn.py:797: UserWarning: `eval_metric` in `fit` method is deprecated for better compatibility with scikit-learn, use `eval_metric` in constructor or`set_params` instead.\n", " UserWarning,\n", "/usr/local/lib/python3.7/dist-packages/xgboost/sklearn.py:797: UserWarning: `early_stopping_rounds` in `fit` method is deprecated for better compatibility with scikit-learn, use `early_stopping_rounds` in constructor or`set_params` instead.\n", " UserWarning,\n" ] } ] }, { "cell_type": "markdown", "source": [ "A more thorough approach is to use larger values, say, `n_estimators = 5000` and `early_stopping_rounds=100`. By setting `early_stopping_rounds=100`, you are guaranteed to reach the default of 100 boosted trees presented by XGBoost.\n", "Here is the code that gives a maximum of 5,000 trees and that will stop after 100 consecutive rounds fail to find any improvement:" ], "metadata": { "id": "iFNCBPFVnoI-" } }, { "cell_type": "code", "source": [ "model = XGBClassifier(random_state=42, n_estimators=5000)\n", "eval_set = [(X_test, y_test)]\n", "eval_metric=\"error\"\n", "model.fit(X_train, y_train, eval_metric=eval_metric, eval_set=eval_set, early_stopping_rounds=100)\n", "y_pred = model.predict(X_test)\n", "accuracy = accuracy_score(y_test, y_pred)\n", "print(\"Accuracy: %.2f%%\" % (accuracy * 100.0))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "TM8sE9vJmqrf", "outputId": "be9a8754-3fa0-4e34-d8a1-1a9407333ec9" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "[0]\tvalidation_0-error:0.23684\n", "[1]\tvalidation_0-error:0.22368\n", "[2]\tvalidation_0-error:0.22368\n", "[3]\tvalidation_0-error:0.21053\n", "[4]\tvalidation_0-error:0.22368\n", "[5]\tvalidation_0-error:0.18421\n", "[6]\tvalidation_0-error:0.21053\n", "[7]\tvalidation_0-error:0.22368\n", "[8]\tvalidation_0-error:0.19737\n", "[9]\tvalidation_0-error:0.19737\n", "[10]\tvalidation_0-error:0.18421\n", "[11]\tvalidation_0-error:0.18421\n", "[12]\tvalidation_0-error:0.19737\n", "[13]\tvalidation_0-error:0.17105\n", "[14]\tvalidation_0-error:0.18421\n", "[15]\tvalidation_0-error:0.18421\n", "[16]\tvalidation_0-error:0.18421\n", "[17]\tvalidation_0-error:0.18421\n", "[18]\tvalidation_0-error:0.18421\n", "[19]\tvalidation_0-error:0.19737\n", "[20]\tvalidation_0-error:0.18421\n", "[21]\tvalidation_0-error:0.18421\n", "[22]\tvalidation_0-error:0.18421\n", "[23]\tvalidation_0-error:0.18421\n", "[24]\tvalidation_0-error:0.18421\n", "[25]\tvalidation_0-error:0.18421\n", "[26]\tvalidation_0-error:0.18421\n", "[27]\tvalidation_0-error:0.18421\n", "[28]\tvalidation_0-error:0.18421\n", "[29]\tvalidation_0-error:0.18421\n", "[30]\tvalidation_0-error:0.18421\n", "[31]\tvalidation_0-error:0.17105\n", "[32]\tvalidation_0-error:0.18421\n", "[33]\tvalidation_0-error:0.18421\n", "[34]\tvalidation_0-error:0.18421\n", "[35]\tvalidation_0-error:0.17105\n", "[36]\tvalidation_0-error:0.17105\n", "[37]\tvalidation_0-error:0.17105\n", "[38]\tvalidation_0-error:0.18421\n", "[39]\tvalidation_0-error:0.17105\n", "[40]\tvalidation_0-error:0.18421\n", "[41]\tvalidation_0-error:0.18421\n", "[42]\tvalidation_0-error:0.18421\n", "[43]\tvalidation_0-error:0.18421\n", "[44]\tvalidation_0-error:0.18421\n", "[45]\tvalidation_0-error:0.18421\n", "[46]\tvalidation_0-error:0.18421\n", "[47]\tvalidation_0-error:0.18421\n", "[48]\tvalidation_0-error:0.18421\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.7/dist-packages/xgboost/sklearn.py:797: UserWarning: `eval_metric` in `fit` method is deprecated for better compatibility with scikit-learn, use `eval_metric` in constructor or`set_params` instead.\n", " UserWarning,\n", "/usr/local/lib/python3.7/dist-packages/xgboost/sklearn.py:797: UserWarning: `early_stopping_rounds` in `fit` method is deprecated for better compatibility with scikit-learn, use `early_stopping_rounds` in constructor or`set_params` instead.\n", " UserWarning,\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "[49]\tvalidation_0-error:0.18421\n", "[50]\tvalidation_0-error:0.18421\n", "[51]\tvalidation_0-error:0.18421\n", "[52]\tvalidation_0-error:0.18421\n", "[53]\tvalidation_0-error:0.18421\n", "[54]\tvalidation_0-error:0.18421\n", "[55]\tvalidation_0-error:0.18421\n", "[56]\tvalidation_0-error:0.18421\n", "[57]\tvalidation_0-error:0.18421\n", "[58]\tvalidation_0-error:0.18421\n", "[59]\tvalidation_0-error:0.18421\n", "[60]\tvalidation_0-error:0.18421\n", "[61]\tvalidation_0-error:0.18421\n", "[62]\tvalidation_0-error:0.18421\n", "[63]\tvalidation_0-error:0.18421\n", "[64]\tvalidation_0-error:0.18421\n", "[65]\tvalidation_0-error:0.18421\n", "[66]\tvalidation_0-error:0.18421\n", "[67]\tvalidation_0-error:0.18421\n", "[68]\tvalidation_0-error:0.18421\n", "[69]\tvalidation_0-error:0.18421\n", "[70]\tvalidation_0-error:0.18421\n", "[71]\tvalidation_0-error:0.18421\n", "[72]\tvalidation_0-error:0.18421\n", "[73]\tvalidation_0-error:0.18421\n", "[74]\tvalidation_0-error:0.18421\n", "[75]\tvalidation_0-error:0.18421\n", "[76]\tvalidation_0-error:0.18421\n", "[77]\tvalidation_0-error:0.18421\n", "[78]\tvalidation_0-error:0.18421\n", "[79]\tvalidation_0-error:0.18421\n", "[80]\tvalidation_0-error:0.18421\n", "[81]\tvalidation_0-error:0.18421\n", "[82]\tvalidation_0-error:0.18421\n", "[83]\tvalidation_0-error:0.18421\n", "[84]\tvalidation_0-error:0.18421\n", "[85]\tvalidation_0-error:0.18421\n", "[86]\tvalidation_0-error:0.18421\n", "[87]\tvalidation_0-error:0.18421\n", "[88]\tvalidation_0-error:0.18421\n", "[89]\tvalidation_0-error:0.18421\n", "[90]\tvalidation_0-error:0.18421\n", "[91]\tvalidation_0-error:0.18421\n", "[92]\tvalidation_0-error:0.18421\n", "[93]\tvalidation_0-error:0.18421\n", "[94]\tvalidation_0-error:0.18421\n", "[95]\tvalidation_0-error:0.18421\n", "[96]\tvalidation_0-error:0.18421\n", "[97]\tvalidation_0-error:0.18421\n", "[98]\tvalidation_0-error:0.18421\n", "[99]\tvalidation_0-error:0.18421\n", "[100]\tvalidation_0-error:0.18421\n", "[101]\tvalidation_0-error:0.18421\n", "[102]\tvalidation_0-error:0.18421\n", "[103]\tvalidation_0-error:0.18421\n", "[104]\tvalidation_0-error:0.18421\n", "[105]\tvalidation_0-error:0.18421\n", "[106]\tvalidation_0-error:0.18421\n", "[107]\tvalidation_0-error:0.18421\n", "[108]\tvalidation_0-error:0.18421\n", "[109]\tvalidation_0-error:0.18421\n", "[110]\tvalidation_0-error:0.18421\n", "[111]\tvalidation_0-error:0.18421\n", "[112]\tvalidation_0-error:0.18421\n", "Accuracy: 82.89%\n" ] } ] }, { "cell_type": "markdown", "source": [ "After 100 rounds of boosting, the score provided by 13 trees is the best." ], "metadata": { "id": "bSdrD_UWn9z2" } }, { "cell_type": "markdown", "source": [ "#### Automatically hyperparamter tuning" ], "metadata": { "id": "826da7dWNGeH" } }, { "cell_type": "markdown", "source": [ "You are encourage to try https://github.com/optuna/optuna-examples/blob/main/xgboost/xgboost_simple.py for hyperparameter tuning." ], "metadata": { "id": "O76mLAlyNNU-" } }, { "cell_type": "markdown", "source": [ "### For categorical variable and missing value" ], "metadata": { "id": "SHHXkhtpJ0w9" } }, { "cell_type": "markdown", "source": [ "XGBoost has experiment support for categorical variable, you can check out here: https://xgboost.readthedocs.io/en/latest/tutorials/categorical.html. But it only works for a few tree methods, it is still recommend to encode your data https://www.kaggle.com/code/shahules/an-overview-of-encoding-techniques/notebook. Missing value, on the other hand can be handled by XGBoost as described at https://xgboost.readthedocs.io/en/stable/faq.html#how-to-deal-with-missing-values." ], "metadata": { "id": "BNREDHc_Ig5E" } }, { "cell_type": "code", "source": [ "# Select target\n", "data = pd.read_csv('melb_data.csv')\n", "y = data.Price\n", "\n", "# To keep things simple, we'll split the columns into numerical can categorical features\n", "melb_predictors = data.drop(['Price', 'Date', 'Address'], axis=1)\n", "cat_col = melb_predictors.select_dtypes(exclude=['int64','float64'])\n", "\n", "# Divide data into training and validation subsets\n", "X, X_v, y_train, y_valid = train_test_split(melb_predictors, y, train_size=0.8, test_size=0.2, random_state=0)\n", "X_train = X.select_dtypes(exclude=['object'])\n", "X_valid = X_v.select_dtypes(exclude=['object'])\n", "X_train_cat = X.select_dtypes(exclude=['int64','float64'])\n", "X_valid_cat = X_v.select_dtypes(exclude=['int64','float64'])" ], "metadata": { "id": "qFSRGgsFI4H_" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "for col in X_train_cat.columns:\n", " X[col] = X[col].astype('category')\n", " X_v[col] = X_v[col].astype('category')" ], "metadata": { "id": "5dJbtmI5-U7t" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "xgb = XGBRegressor(booster='gbtree', objective='reg:squarederror', \n", " random_state=42, n_jobs=-1) # You can either specify missing=-9999 or leave it as it is\n", "xgb.fit(X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "PqKgSpglLclJ", "outputId": "cb544b30-328a-404c-a403-44aedea4f4d8" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "XGBRegressor(base_score=0.5, booster='gbtree', callbacks=None,\n", " colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,\n", " early_stopping_rounds=None, enable_categorical=False,\n", " eval_metric=None, gamma=0, gpu_id=-1, grow_policy='depthwise',\n", " importance_type=None, interaction_constraints='',\n", " learning_rate=0.300000012, max_bin=256, max_cat_to_onehot=4,\n", " max_delta_step=0, max_depth=6, max_leaves=0, min_child_weight=1,\n", " missing=nan, monotone_constraints='()', n_estimators=100,\n", " n_jobs=-1, num_parallel_tree=1, predictor='auto', random_state=42,\n", " reg_alpha=0, reg_lambda=1, ...)" ] }, "metadata": {}, "execution_count": 176 } ] }, { "cell_type": "code", "source": [ "preds = xgb.predict(X_valid)" ], "metadata": { "id": "9JpLF4ECLnha" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1yuRQhnjLtLi", "outputId": "875024d9-f93b-4b39-e0af-0dcd88e1253d" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "173639.76325478646" ] }, "metadata": {}, "execution_count": 178 } ] }, { "cell_type": "code", "source": [ "explainer = shap.Explainer(xgb)\n", "shap_values = explainer(X_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "oVDw3PEvgj6b", "outputId": "00821643-0773-4399-958e-d155e52e3005" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "ntree_limit is deprecated, use `iteration_range` or model slicing instead.\n" ] } ] }, { "cell_type": "markdown", "source": [ "### SHAP values" ], "metadata": { "id": "Z7FHMo3tj_Bj" } }, { "cell_type": "code", "source": [ "shap.summary_plot(shap_values, X_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 411 }, "id": "v2dATeDRgwLh", "outputId": "0b950859-186a-426a-98b7-23b796a1183e" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "## Lightgbm" ], "metadata": { "id": "t58ejslZMJ_P" } }, { "cell_type": "markdown", "source": [ "### Classification task" ], "metadata": { "id": "RiQQUpHDP0In" } }, { "cell_type": "code", "source": [ "iris = datasets.load_iris()\n", "df = pd.DataFrame(data= np.c_[iris['data'], iris['target']],columns= iris['feature_names'] + ['target'])\n", "X_train, X_test, y_train, y_test = train_test_split(iris['data'], iris['target'], random_state=42)" ], "metadata": { "id": "X50nza8ILxQb" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "clf = lgb.LGBMClassifier(boosting_type='gbdt', learning_rate=0.1, n_estimators=100, random_state=42, n_jobs=-1)\n", "clf.fit(X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ff20VXGMQIXR", "outputId": "1a131638-cefd-45df-9754-5e8fd88934f0" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "LGBMClassifier(random_state=42)" ] }, "metadata": {}, "execution_count": 34 } ] }, { "cell_type": "code", "source": [ "clf.fit(X_train, y_train)\n", "y_pred = clf.predict(X_test)\n", "score = accuracy_score(y_pred, y_test)\n", "print('Score: ' + str(score))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "zC6X-CFEQ2m3", "outputId": "d35489eb-ef3d-4ee6-a334-ddf2294e0419" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Score: 1.0\n" ] } ] }, { "cell_type": "code", "source": [ "clf.get_params()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "KcTMWhn8QBil", "outputId": "3e98dceb-2ef7-4c64-b601-18a0a5115e4b" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'boosting_type': 'gbdt',\n", " 'class_weight': None,\n", " 'colsample_bytree': 1.0,\n", " 'importance_type': 'split',\n", " 'learning_rate': 0.1,\n", " 'max_depth': -1,\n", " 'min_child_samples': 20,\n", " 'min_child_weight': 0.001,\n", " 'min_split_gain': 0.0,\n", " 'n_estimators': 100,\n", " 'n_jobs': -1,\n", " 'num_leaves': 31,\n", " 'objective': None,\n", " 'random_state': 42,\n", " 'reg_alpha': 0.0,\n", " 'reg_lambda': 0.0,\n", " 'silent': 'warn',\n", " 'subsample': 1.0,\n", " 'subsample_for_bin': 200000,\n", " 'subsample_freq': 0}" ] }, "metadata": {}, "execution_count": 37 } ] }, { "cell_type": "markdown", "source": [ "### Regression task" ], "metadata": { "id": "W_yDFE8oRmPh" } }, { "cell_type": "code", "source": [ "X,y = datasets.load_diabetes(return_X_y=True)\n", "\n", "lgbr = lgb.LGBMRegressor(boosting_type='gbdt', learning_rate=0.1, n_estimators=100, random_state=42, n_jobs=-1)\n", "\n", "scores = cross_val_score(lgbr, X, y, scoring='neg_mean_squared_error', cv=5)\n", "\n", "# Take square root of the scores\n", "rmse = np.sqrt(-scores)\n", "\n", "# Display accuracy\n", "print('RMSE:', np.round(rmse, 3))\n", "\n", "# Display mean score\n", "print('RMSE mean: %0.3f' % (rmse.mean()))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "SQnUryTZQ-l_", "outputId": "8e67190f-8a7c-4ad0-adfb-d54dd41d6fd9" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "RMSE: [56.081 59.172 63.191 61.833 60.542]\n", "RMSE mean: 60.164\n" ] } ] }, { "cell_type": "code", "source": [ "lgbr.fit(X,y)\n", "lgbr.get_params()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "DeDcf6bhRdOO", "outputId": "d9451285-9cee-438a-b857-58aec5d3ed3d" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'boosting_type': 'gbdt',\n", " 'class_weight': None,\n", " 'colsample_bytree': 1.0,\n", " 'importance_type': 'split',\n", " 'learning_rate': 0.1,\n", " 'max_depth': -1,\n", " 'min_child_samples': 20,\n", " 'min_child_weight': 0.001,\n", " 'min_split_gain': 0.0,\n", " 'n_estimators': 100,\n", " 'n_jobs': -1,\n", " 'num_leaves': 31,\n", " 'objective': None,\n", " 'random_state': 42,\n", " 'reg_alpha': 0.0,\n", " 'reg_lambda': 0.0,\n", " 'silent': 'warn',\n", " 'subsample': 1.0,\n", " 'subsample_for_bin': 200000,\n", " 'subsample_freq': 0}" ] }, "metadata": {}, "execution_count": 52 } ] }, { "cell_type": "markdown", "source": [ "### Speed" ], "metadata": { "id": "gEFp_iDMR8Jw" } }, { "cell_type": "code", "source": [ "df = pd.read_csv('exoplanets.csv')\n", "# Split data into X and y\n", "X = df.iloc[:,1:]\n", "y = df.iloc[:,0]\n", "\n", "# Split data into train and test sets\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=2)" ], "metadata": { "id": "sFvSB-AoSM-g" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "start = time.time()\n", "\n", "# Instantiate the XGBRegressor, xg_reg\n", "lg_reg = lgb.LGBMClassifier(n_estimators=100, max_depth=2, random_state=42)\n", "\n", "# Fit xg_reg to training set\n", "lg_reg.fit(X_train, y_train)\n", "\n", "# Predict labels of test set, y_pred\n", "y_pred = lg_reg.predict(X_test)\n", "\n", "score = accuracy_score(y_pred, y_test)\n", "\n", "print('Score: ' + str(score))\n", "\n", "end = time.time()\n", "elapsed = end - start\n", "\n", "print('Run Time: ' + str(elapsed) + ' seconds')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "P2mf-IgRR3zt", "outputId": "108b41d9-5f96-48e3-d77c-5a413ee77d85" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Score: 0.9913522012578616\n", "Run Time: 7.302560567855835 seconds\n" ] } ] }, { "cell_type": "markdown", "source": [ "### Hyperparameter" ], "metadata": { "id": "rfvM90-HSayn" } }, { "cell_type": "markdown", "source": [ "Following set of practices can be used to improve your model efficiency.\n", "\n", "* **num_leaves** : This is the main parameter to control the complexity of the tree model. Ideally, the value of `num_leaves` should be less than or equal to 2^(max_depth). Value more than this will result in overfitting.\n", "\n", "* **min_data_in_leaf** : Setting it to a large value can avoid growing too deep a tree, but may cause under-fitting. In practice, setting it to hundreds or thousands is enough for a large dataset.\n", "\n", "* **max_depth** : We also can use `max_depth` to limit the tree depth explicitly." ], "metadata": { "id": "vJIrKihuSd83" } }, { "cell_type": "markdown", "source": [ "1. **For Faster Speed**\n", "\n", "* Use bagging by setting `bagging_fraction` and `bagging_freq`.\n", "* Use feature sub-sampling by setting `feature_fraction`.\n", "* Use small `max_bin`.\n", "* Use `save_binary` to speed up data loading in future learning." ], "metadata": { "id": "Xiv_JVHiS4ww" } }, { "cell_type": "markdown", "source": [ "2. **For better accuracy**\n", "\n", "* Use large `max_bin` (may be slower).\n", "* Use small `learning_rate` with `large num_iterations`\n", "* Use large `num_leaves`(may cause over-fitting)\n", "* Try to use categorical feature directly." ], "metadata": { "id": "X4V_yKNBS_CI" } }, { "cell_type": "markdown", "source": [ "3. **To deal with over-fitting**\n", "\n", "* Use `min_data_in_leaf` and `min_sum_hessian_in_leaf`\n", "* Try `lambda_l1`, `lambda_l2` and `min_gain_to_split` to regularization\n", "* Try `max_depth` to avoid growing deep tree\n", "* Try `dart`" ], "metadata": { "id": "SFw9dI43TLbA" } }, { "cell_type": "markdown", "source": [ "Check https://lightgbm.readthedocs.io/en/latest/Parameters-Tuning.html for hyperparamter tuning." ], "metadata": { "id": "OnbuqeIvTXP5" } }, { "cell_type": "markdown", "source": [ "### For categorical variable and missing value" ], "metadata": { "id": "V7LmHQzR7RtF" } }, { "cell_type": "markdown", "source": [ "LightGBM enables the missing value handle by default. See https://lightgbm.readthedocs.io/en/latest/Advanced-Topics.html#missing-value-handle. It also deal with categorical variables as described here https://lightgbm.readthedocs.io/en/latest/Advanced-Topics.html#categorical-feature-support" ], "metadata": { "id": "HTaO1Nx47YZd" } }, { "cell_type": "code", "source": [ "# Select target\n", "data = pd.read_csv('melb_data.csv')\n", "y = data.Price\n", "\n", "# To keep things simple, we'll split the columns into numerical can categorical features\n", "melb_predictors = data.drop(['Price', 'Date', 'Address'], axis=1)\n", "cat_col = melb_predictors.select_dtypes(exclude=['int64','float64'])\n", "\n", "# Divide data into training and validation subsets\n", "X, X_v, y_train, y_valid = train_test_split(melb_predictors, y, train_size=0.8, test_size=0.2, random_state=0)\n", "X_train = X.select_dtypes(exclude=['object'])\n", "X_valid = X_v.select_dtypes(exclude=['object'])\n", "X_train_cat = X.select_dtypes(exclude=['int64','float64'])\n", "X_valid_cat = X_v.select_dtypes(exclude=['int64','float64'])" ], "metadata": { "id": "69qkUi3qTWxS" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "for col in X_train_cat.columns:\n", " X[col] = X[col].astype('category')\n", " X_v[col] = X_v[col].astype('category')" ], "metadata": { "id": "N3DIZVNS9d4d" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "lgbr = lgb.LGBMRegressor(boosting_type='gbdt', random_state=42, n_jobs=-1)\n", "lgbr.fit(X, y_train)" ], "metadata": { "id": "jiF3wMm7SHRP", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "8a07db4b-b48b-401f-dd98-3cfaf98f9584" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "LGBMRegressor(random_state=42)" ] }, "metadata": {}, "execution_count": 158 } ] }, { "cell_type": "code", "source": [ "preds = lgbr.predict(X_v)" ], "metadata": { "id": "brGm9FFR8eIf" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "wpS4eGVe9ujW", "outputId": "fd13a1a8-e48c-4811-f918-d5db5fd39463" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "160267.37406568974" ] }, "metadata": {}, "execution_count": 160 } ] }, { "cell_type": "markdown", "source": [ "### SHAP values" ], "metadata": { "id": "RQpYAqIKkEM6" } }, { "cell_type": "code", "source": [ "explainer = shap.Explainer(lgbr)\n", "shap_values = explainer.shap_values(X)" ], "metadata": { "id": "RrbIM2sUg5_B" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "shap.summary_plot(shap_values, X)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 542 }, "id": "Oeql_GBTiMwh", "outputId": "08e906f1-cf14-4d3e-8eb5-997e33285888" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAINCAYAAAD/Wz8DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeZwcZZ348c9T1dfcM0mYhCFMyJBwRiD4cMqpoME1i4AuCigYYX/hWJdFERYFuZXFRV0VUSDCKmgUIgIu4VCCcoaHBEJCIIQck/uae/quqt8f1dPTM5lJZiaZo3u+77z6leqqp556qqun+9vf56kq5XkeQgghhBAjlTXcDRBCCCGE2BUJVoQQQggxokmwIoQQQogRTYIVIYQQQoxoEqwIIYQQYkSTYEUIIYQQI5oEK0IIIcQoo5Rao5Sa1m2eUUqdppS6VSl1fh/quFkp9cPBa2WnwFBsRAghhBD5wfO8m4a7Dd1JZkUIIYQQWUqph5RSV2WmK5RSjyul3ldK/VUp9b/dsin7KaX+L7P8L0qp4sFok2RWhBBCiNHpMaVUPOf5QT2UuQlo9DzvEKXUGOAt4PGc5Ro4BmgGngUuBO7f2w2VYGV0kXsr5ImnnnoKgJkzZw5zS4QQg0gNXs3ndv289+b1tK0veJ63NLuKUqaHMqcD/wbgeV6DUuqJbsuf9TyvKbP+G8CBe9Ls3kg3kBBCCCEGKjcz4zBISRAJVoQQQoiCo7o9BmwB8FUApVQlcPaetmwgJFgRQgghRG9uBaqVUu8DfwIM/viUISVjVoQQQoiCs+tsiud5B/QwT2cmF+TMbge+7HleXClVDrwM/CpT/uZu63d5vjdJsCKEEEKI3lQBzyilbCACPOp53gtD3QgJVoQQQoiCs3dONPI8byvw8b1S2R6QMStCCCGEGNEksyKEEEIUnMG7hMtwkMyKEEIIIUY0CVaEEEIIMaJJN5AQQghRcKQbSAghhBBiyEhmRQghhCg4hZVZkWBFiEEyZ84cVq5ciVKK2tpapk+fTjQapa6ujtra2p3KL1y4kBdffJHGxsbsvPHjx3PssccOZbOFEGLEUZ7n7b6UKBSj7mAvXLiQp556ilQqBUB1dTWJRIJgMEgikaCtrQ2AiRMncuWVV+7x9ubOncs777yD67q7LTt9+nROOOEEfvvb39LS0tJruXPPPVcCFiEK0+ClP9SXu37ee7/L61SLBCujy6g62HPmzGHFihV9Lm9ZFuFwmAkTJnDWWWcBsGjRIurr62loaCCRSDBcfy+HH344p556KrW1tdkMTFtbG4FAgP3335+mpiYATjrppN0GNnPnzmXp0qV4nofrugQCAU488URmzJgxFLsihOgkwUofSbAyuhTMwa6vr2fRokW0trZSVlbG0Ucfnf0inz9/PtFodLibOGzC4TAnnHACkUgk2+U0f/58Xnrppd0GW8FgkJkzZ0omR4ihMYjBygXdgpVHJVgReaMgDnZ9fT333nvvcDejoJ122mmsXbuWzZs3E4lEOP300yWAEWLvk2CljyRYGV3y6mB3ZE8AampqeO2119i2bRvpdHqYWyaUUliWhed5VFVVcf755/c4aLhDfX09q1at6nVwsRCj1CAGKxd2C1YekWClEGmtTwNeMMbs1TOmtNaXAN81xkzZm/X2UV4c7Pr6el566SWWLVs23E0RQ0gpxdSpU5k1axYgAY4YFSRY6aOCPnVZa10H3AWcDJQCjYABzjfGJIezbaLTwoULef7554lGowSDQeLx+HA3SQwDz/NYsWIF119/fZ/Kh8NhAoEA1dXVnHXWWTsFNPPnz2fp0qVMmzZNBg+LUSivY5OdFHSwAvwf8BxwMNAC7Ad8jmE6ilrr4HBsdzj19Ou4vr6euXPnsmPHjp3KO44z1E0UeSqRSJBIJFi9evUuxzAtWLCABQsW7DRfKdXjgOOe5luWhVKKQCCAbdvZbrC2tjaUUpSVlZFOp6moqMDzPFpaWqiurmbSpEl89NFHBAIBEokE7e3tTJ8+vUvwJBkkIXavYLuBtNZjge3A4caY93pYfjNwkjHmjJx5C/C7fm7v6AYCvg7cCpQBTwJXGWPaMuU94GRjzMuZ56eR03WUqe9t4ADgk8CdwGbgu8D9wNWADfwGuN4Yk9qLL0FPBvVgL1y4MPtLdvXq1SxZskSCDyF6EQwGcRynyzV5LMvCdV2CwSCWZZFMJgmHwxQVFZFIJHBdl1AohFKK8ePH09TURCqVIhKJ0NbWRjQaxfM8SkpKmDJlCmvWrKGtrQ3btqmtrSUWi5FOp7PZy5qaGg4++ODsxQo3b97M0qVLqampIRKJsGjRIrZt25bd3qRJk6ipqelyccPefpD0Nq+4uJhoNJr9v7d6upevq6sDGDGB3V4KMgfth7OnvtLl8155v8nrVEvBZlaMMTu01suAB7TW9+F3/yw3xvTnC9sGZgJHABHgT8A9wL/2o45ZwOeBc4Ai4F+ASUAtUAfUAM8AO/CDmby0cOFC5s2bB9Cva5sIMVp1XKgwV0fgkrssHo936RrtmG5ubu617tbWVhYvXtxlWz39XTY2NmbHhuVmlLqX9TyPTZs2sWnTpuw8y7L4/Oc/zxNPPIHruliWxezZswG47777ep3XXU/15D7voJRCKdWl3uEKWOrr63fax+EOngpdod/I8DRgAX4G421gi9b6Rq11fyLM64wxzcaYLcBNwFe11v153R4zxvzNGOMZYzou/uEC1xpjYsaYj4D/Ai7pR50D0traOmjTS5cu3buNFUIMqf5m2V3XZenSpdmAwnVdVq1axfLly3eat2rVql6v6txTPbnPc9vXvd7B/Ezb1XRP+ziQekTfFXSwYozZboy5wRhzNFAJfBs/4PhaP6pZmzO9BggD4/qx/poe5m3NCVw6ykzsR50DUlZWNmjT06ZN27uNFUIMKaX610tgWRbTpk3Dsqzs87q6Og499NCd5tXV1WXn9aWe3Oe57ete72B+pu1quqd9HEg9g0t1e+S3gu0G6i4THDyktf434Cj8IKSkW7GaHladBHyUmT4ASOCPhQFo61ZHT+v39HOiWmtdnBOwHACs380ujGgdFwzLHbOybNkyPM/L9r13/HLrbWCjEKNJx5gVIDt4N51O4zhOXo1ZmTBhwk5jN2bPnt3rvN7GrHSvp+P5SByzUltb2+M+isFTyANsq/AzKY8AH+APLj0beBS4CNgGPAucCLwDzAZ+BNySM8D2ReCPwKX4Y1bm4Y97uSyzjQXARvwunBrgMeCobgNsXzDG3J7TrkvwB9fel2nfvvhnLf3GGHPHILwUuUbUwZ47dy7vvvsuruv26cZ/QuyKbdsEAgFSqVT2/WTbNq7ropSipKSEcePGUVxcTENDQ/YLMJlMsm3bNkpLS6murqampoaNGzfS2tpKLBYjlUpxzDHH9HoFXzmbR+yBQUt5uOriLp/3lvdwXqdXCjmzkgSq8QOMfYE0fnfLN4wxfwTQWt8DzM+Uvw94pVsdDvAX4F2gHHgKuCZn+VXAHKABeA94CPhxH9q2Fj+Tshp/EO8j+ONWRpXzzz+f888/v8u8+vp6nnjiCTZt2iTZl1GquLiYWCyWzTR0vA8sy6KqqoqpU6dm7wU1EtTW1o6YtghRqAo2syJ6lFcHu+Ny+++99x4tLS3D3RyxC5ZlMW7cOBKJBOBfA8VxHBzHyQYbnuehlKKoqIjJkycTCoVYsWIFnucRDoepqanJ3llaiFFiEDMrl3TLrDyU15kVCVZGl7w+2PPnz2fx4sUEg0G2b9+++xXEXldWVkZtba0EFULsHRKs9JEEK6NLwRzshQsX8uabb7J169bsr/mOC2oJ3/Tp0xk/fjzxeJyXX365zzeA3H///bnyyisHuXVCCAY1WPlat2Dl1xKsiLxR8Ae74yq669evJxqN7n6FHlRUVHDhhReyefNmnn/++RFxXYRgMMjMmTMBP8PU275ZlsWRRx6501igjvVef/31Hu+9VF1dzUknndTrIFIhxKCQYKWPJFgZXUbVwb7nnnvYunVrn8qWl5dz0UUX9dq1UV9fzzPPPMP69etJp9PYtk11dTW1tbXU1NTwwQcf0NLSQiKR6PM2wT9bZXe3JIhEItx88819rrMv5CZ/QowIgxZAOGpWl89725sjwYrIG6PyYPf2xZx7L6PByCjMmTOHlStX7tQ1FQwGCYVCHHPMMcyYMYP6+npeeuml7GXPu7viiitkfIgQhWkQg5WvdwtWHpRgReQNOdgjWO6N21599VUAzj33XAlUhChcEqz0USFfZ0WIvJJ7vY4tW7Zk5wkhRH8V2i/Tgr43kBBCCCHyn2RWhMhT9fX13HvvvV3mWZbFnXfeOUwtEkKMHHnd67MTCVaEyEM9BSrg367++uuvzz6vqqriuuuuG8qmCSHEXifBihB56E9/+lOfyjU2NmaDF7nYmxCjh1dgmRUZsyJEnlm4cCGbNm3q93rr1q3j5z//+SC0SAghBpdkVoTIM/PmzRvwuuvWrduLLRFCjFySWRFC5LHrr7+ee+65Z7ibIYQQfSbBihB55Dvf+c5eqWfr1q1cf/31zJ8/f6/UJ4QYWTxUl0e+k26gHmit23KehjP/JzpmGGNKh7ZFor/q6+tZtGgRa9eu7df4junTp/d4E8CezJkzhw8//BDP8zjooIOYNWvWQJvbJwsXLtztfYT6a8GCBSxYsACQAbhCiJFLLre/G1rrB4CAMeaS4W7LXjAiD3bHPXpqamqIx+MsX76c1tZWgsEgZWVlNDY24rouY8eOZdq0abzzzju0t7eTSqXI5/dvVVUVp59+eo/3JXrqqacAsndaXrhw4R6NVdlToVCIE088UW56KMTeNWgpj6Sa3eXDMeTdl9fpFcms9IPW+nJgtjHmyJx5BwIfAAfiv/FWA5cB3wbGAwuAy4wxWzPli4FbgfOACmAhcJUxZuXQ7Un/5d635oMPPmDbtm2UlJSQSCTYsmXLLn/xK6X6FFSsWLGiy/NEIkEikU1osX379mwWoBA0NjYyb948nn76aS699NJdXlr/5ZdfHsKW7SyZTHbJwoAfwFiWhed5KKWoqalhxowZcosAIUaAQuj6ySVjVvrnEeBArfUxOfO+DrxgjFmbM++rwCnA/oAL/DZn2f3AIcDxwATgDeBprXVwMBu+J+rr67nvvvuYP38+8+bNY9myZWzdupXVq1ezcePG3XZN5HP2Yygkk0nuvfde6uvre1xeX1/P1q1bh7hVu5dMJonH4yQSCeLxOKtWreIXv/hFr/shhBADJcFKPxhjWoDf4wcoaK1t4GL8ACTXLcaYzZny1wJnaq1rtNbjgAuAK4wxW4wxSeAWYF/guMFuf2tr64CmV61aheu6g928UW/VqlVdXv9QKJSdny88z8u2d6DvN5mW6dEyLfpOuoH675fAC1rra4BP4b+GT3Yrs6aH6Yl0jhlZorXOLR/Ez8IMqrKysgFN19XVYVmWBCyDrK6ursvrn0wms/PzhVIq296Bvt9kWqZHy7ToOwlW+skY86bW+iPgi8A5wEPGmFS3YgcAH+VMA6wH0pnpqcaYbYPc1L2mtraW2bNnD/qYldGquLiYSy65pNexHrW1tVxxxRU93gtoOMmYFSFGrkIbsyLBysD8Cvgm/tiTa3tYfqPWeikQA+7CH9OyEUBr/Shwr9b6amPMBq11JXA68Lwxpq2HukaE2tra7JdQT2evjBRz585l8eLFe1SHUoqpU6d2ORV5/vz5LF68mFgsls14dGfbNmefffZOr89dd91FY2PjHt1UsLa2lh/84AddblI4GKqrq7nmmmsGdRtCCNFfEqwMzCPA3cArxpgPe1j+W+Af+GcD/R34Ss6yy4AbgAVa6wlAU6bsc4Pa4lHi/PPP7/U6KR2nSE+bNq3fAdeMGTMGfNruSL7rsdyVWYhCVViZFbnOygBorRWwCviOMebRnPkH4J+6vL8xZv0wNW9X5GDnie7XWcm1N7IrSikuv/xy6bIRYngNWkQRV1d2+byPeD/P6+hFMisDcyEQAh4b7oYI0V/FxcXcdNNNw90MIcQgkjEro5zWehv+QNlZmVOPhRhSBx100E4X0Osry7IkUBFC5B0JVvrJGLPPLpatodA6CsWIM2vWLG699Vai0Wi/1gsGg9x2222D1CohxMhSWF9FEqwIkYdmzJjR53sFyQ0KhRh9pBtICDHsjj32WN58803WrVvX4/J9992Xc845RwbQCiEKggQrQuSpK6+8krlz5/Luu+9i2zYnnHCC3BVZCFGQJFgRIo/t6royQghRKORGhkIMopc+SnDQna0c8f0m3l4lJ48JIYaGh+ryyHcSrAgxSH70YpQZcz0+DBXxgRfhjAfinPXTBlKOXJtPCCH6Q4IVIQbBrc/H+OH8BJO2N1EcT5J0YUfa48V6i4n/2cQf34oNdxOFEAVNdXvkNwlWhNjL7n8zwX89E2PWa++wZp9KopEQRAJQFiaBIg5c/+sWEu2936k6Ve+x+Yfw+MnPsOyWxaRj6V7LCiFEoZN7A40ucrAH2a3Pxrj9H2k+taKe9ftWsXT/6s6Frgub/BtrF7sup7RGCbse+7S3URJPUpaOc/Jnx7HphY20rokSKy8mmExRua2F0kSKmYtmYpUFCRYHh2nvhBB72aClPNrUf3T5vC/1fpTX6RUJVkYXOdiD6OklCb7+SIxGV1GES8v4sq4F2pPQFM8+nd4aZWLaQeFR3R5jysZN2GmXoniC9opSSpvbqWhsB0A5LiXNKQIpF9txqHDaieCSQmHjp0gVHgFiFNeWsd+rFxLer2Lodl4IMRASrPSRnLosxB5KOR5ffyLKb1bYUBLGtkElU13K2GmHcHuSpOcx1nUpcjzKbZsW20Z5HsqyCNRM4PAP1/gZGA/Kmjsvp+9ZimDcIeK4KCBBER5pKmnFApKEAHAJ49XvYOPEH2MTJU2QkmCcyO0zKf3KdOx9y4fuhRFCDJtCOAMolwQru6C1Xgncbox5aDflbgBOMMbMHJKGiREh7Xj8vyeizFmmsAM2RNNQEcZRiuZw166aIzY1s097km2hIOVph5qYn2HZHg6RtG0q26MUJ5KkbRvb9YhEE6Rtm5Drj1Wx0x7hTKAC4GHhYdFCKWV0Dta1gQR+RidEkP15Dzvl4l73AJuum0RRJoDxyosZ/9qlqMP2G/TXSQgh9lTeBSta6wXAC8aY24e7LR2MMXcOdxvE4IqnXJ5b6ZCKp/nr0gQPrAhQhEciHICwDY6XGXSf82vG9SDtQjLN4jFlhCtcpjZF2b+ljVCm+3VCPMGGogjjojEqY3HSoQCObeMUhUiFA5Q3tlHUnqBye6Jbi7zMv45rKHh0zygnibCZg4hSQhEtTGQFHkFSFJNoSbL58F/g4hAmiUKRDIewVZzSogTWNZ8i+KkjsKfXQiSU2WQmq6wK6xebEGLky7tgRYju0q7H75Z7vLnZY59ij5ClmFoFjy5zeXGtSzrtQcIh4rlYQYuxRQo37dKQUrTEPWJJz/8CTrtgKSylcBNJCAbAsiDldMYCRUEIFkGZIuUBnkco7ZIMByBkQ9qBgO1/sVvKnxe0IOaQCNhsKglzZENn2wOeR008TmN5Gfs0NBNJpMDzSAQsnGCAxupKnG2tlEcStEUCjNseAxQWTuZUPkUrRYRJEMHBb6i/xMbFIUSEFAkiJCgmwT6ZHXEIkAAUDiGCxKhO1JMiTHt8PEU3/pXkjc8ToxiFhcIDEihcLFxcLELEgBQKDxc/k5SmmAAJLBIkGINNEos4CoXCybTYI02IlF1GwElm9iVFQLVh15ThJBXpbQkSFGNjYeOhAmmC5Q6uCpJ2iiASwG7aRiDiYX1zJhx/EN63/he3NYk3tgpVU4H1yUNQloJoEu/xhTib2nAJYR1Rgx1tRZVF4KhJJEvH4LxVT2BqFcFLT4Gn34apE+CMw+H3L0N7And8Nd66RqxzjkLVVPb9zfnq+/C7lyGWgJoxMFPDMVN7Lvv+enhhCRwzBY47qO/bEKIH0g00QmmtvwT8JzAZaAeeBK4xxrRnlq8BfgV8CjgOWAP8qzHm1czyIHAXcBHgAj/qVv8BwC8z63rAauDLxpgPtNY3AycZY87QWp8HPJyzqgKKgenGmLe11rXAPcBJmXqeAr5pjGndiy/HqHLJMy6PLM8dS9YxrfA7RoBwgJbmBLQ6bA5mhqR6XiYIsfwsiAu4Hm7AgqII2ApiKX++AoqDUBKEuAOtDtiKjze28NbEMZ2btizUlna8irB/ujL4gVAm+RH0POLBAHYqTcB1UUoRcj2CqRQlma4hlCKYSOEEA+B5xMrDtFWGCaYcsCHo+EFJ50eRIk0Qi3Rm710CxAhgE8gECCFSqMz1FmzilLEeC4d2KmlhP6qoz7xaaSyas69bAA83e4WDIiI0EKMKUCQopoTtBGhDEaWBOlzCJAGbBEEcIEKAGCGas0fGJUiaSkqcFjws/1gQwPHKsTc0EMAjANhYJKnABUgHcRrSFLOFAJCilBCtEAdu/F02lrQBVm3wm/vnVzLtDpCmBIciII237n1s/D8358m3SROhuKN9dz+OSmT299Qp8NISHCI4+GN9nB88S3DJd1FVJb28G3O8+C6ccbP/3upw5+Pwws1w2rSuZT/cCMd8G9riYFvw7E3wqSN2vw0hRolCus5KM3ABUAmcnHl8t1uZWcA3gArgeboGFdcDnwNOxA94DgAm5Sy/E6gHxgPjgEuAxu6NMMY8bowp7XgAjwCvA+9rrSPA34D3Mts4DJgI/GSA+yyAv6zq40lOYTvThZHzi6OjS6MjoAB/gKul/K6dju4dS/nBiuNBwh8AS9qjRdmUJnOugeJ6fvYl5XR2m8TTBNIuFYkURza0+iGD6wdKDn4s5Ng2bk73ip12CCaSBOP+JfpDCZdwPE1jZYSWkjBuJtfRwQOS2Hh4fn2EUf7XvN8sgnSEChEasDJBTAlNhGnp9htM5dRrdZmfIpKzXOEQxg9pFC7hbEmHYI/T/qvvZaY7s0D+86575WQGDXeuaeMSzJ711HOLe6KymR9/nwI5a1gU0dJZMtF5thYLVwN02S/WN+It2bDLrWX99d2ugQqA48Kzb+9c9u/v+YFKR5n5i/u2DSF6JReFG5GMMc8YY5YZY1xjzErgXvwsSq5fZso4wAPAFK11x/mdXwXuMsasNMbEgG/R9VTfJDABqDPGOMaYJcaYrbtqk9b6RuA0YKYxJo4fDCljzE3GmJgxphG4EbhQa23v0QvQB62trQU5fcKE3i+u1kXKyXx59BDcdGRZwA9cPC/3O3nnMh1VKsVJa3egmuOwIwatSTwFlISgKc6EDU2cu3IT563ZwpkbdlCWckgqxYZICMe2QCk8pdgcifDBxAnEgkFC8SSepQikHQKuSyCZprIhRllzkmgkzMJjpuJmAhMr0y2jUARwCJMmQhIPiwi5yTqXMK2UsxYvZyc8IEVRl92yacuMh+ko4U9ZpAjRlvP6edgk6bgLiUUip47OAM6ipwvaKTxsyAmo/EHDue2Id9mWXyKNB5kgiZx1dy23DSrbXQbgEqe0sx47J8g6qDqzbs49ncaW0F7beUr6Lt+fpx7W83fESYfsVL798BoI5SS6Tz509/XLdN5Pi74rpG6gM4GbgEOAMH5GuHswsSlnuj3zfxl+VmYiftcQAMaYdq117vrX4gcWT2mtS4DHgP80xrT10p6LgauAE40x2zOzJwO1WuumbsU9/ECojz/ZBqasrKwgpx/7fIh733Z5bSOMi3gUBRX7lcJvlrqsaPDwHBcv4RB0HVSJTSQItusQdRWxpIfjAMr/8rItCLgOXluSZGnYz8YkM19uLUkoDUJQQcr/gg67LmvCIbxk5kvX9fx1LAVVRYxLJAl3jEv1PNaEgzTbAWrjXQfMWgrWjhsD4RCHLfuosy5LURRNEXD8+uOhCMXtCZwwRBJ+3sOv3iWCf7q0QrEP9YyjnnbGkqSIGBWsYDoB0tTwYXa7MSpxiOASxiLhJ5GI08q+gCJMGyHaUVjYxLBQlLCJNBECpLCJkyBEmjJsoihSBIlhk8ChPFNnAocgCgeXAA4BIE4bpZksSTLzaIGSMG7cwXUs4gRRpLFxAIdAOI5jlZF2inAsC5JpAkEX9ZVTUGcehfefj+K2JKCsCDWhEnXSFFRRGJpjBJ5dgtocw1UhrIP3hdYmCNvYh+2HVb0vsaUbCNRVEfzXU+HPi2DKeOwvHgf3PYvdFoex4/A2t2J/+RhCkyf07f155lHw11tgzl+hKQoTKuC8E2DG0TuVLzn+MHjpNvi/RXD8QfDZj+/VvxGZHpnTg0nGrIxAWusQ8ATwbWCOMSamtb4KPzvSVxvwu3466iwB9ul4bozZht+F9A2tdR3w58z2buqhPWfid+182hjzUc6itcAKY8zh/WiX2I3ioOJbx+ycmLr22L2XrFrT6PD8h2k+2JzknY/SLFuTZlN5CRHPodHqtp2cz4hVY4o5fFtLNqgYl0xjBRVljpsdZ+EAccsi6HkUtcdQLozd0oKnoKWqhPImv8vDBfZbu4P91u6g2E1m06Iqsyz3fKBIpmujhB2UAGnCBChhDA0UEcXBop1xJCijjHW0MoYACQKkSI4dh33aUahxxRRfcDjWcQeiFDgxB6/IJtieIFhR7A8+BiL9eB390Sn+r4neRn2oTLnePtJ7+9BS//IJejviahfrhbvPmD65c/rfPwfQa727dfrH/EdfHH+w/xBC7CRfg5VAZvxH9jn+Z05jJlA5DD+r0R+/Aa7NnBq9EfgvcrrJtNbnAwvxsy/N+N1CO/U/aK2PAOYCXzHGLOy2+Gngjsx1WX4KtAE1wLHGmD/1s71iCB1QZXPZsTbdv9rO/63HH1Y4WMlMD5OtINz5ZxUNBXl7bAk1LQnilj8qozaRRClF3Pa/AlOWIui67L+jmf3XbWZMc+aqtR6UN7Rjp122VhcTjLoUZe4RlFQ2RV7n28/Dop0IRSTwUJnshS+hwqwt2ocDotsBm0bG0x4eQ9UPPsM+V5+00772FnzYoUwXSUgu9y/ESCeZlZHhe5lHrpuA/9Ja/wp4E3gUf0BtX30fGIM/GNbBPxtobc7y6cDdwFigFf8snnkIHiIAACAASURBVLt7qOdc/AG8v9Na584/wRjzrtb6k5ltvY//43EjfnAjwUoemntRCffHHA65s51NpRG/P0cpwqk0iWCA8miCcW0pGkMhNoQCRAMWk7ZnBnRmxsZMbGqhevN2xjW1kAgFcSyFnRmY2VJaTGksTtOYEvb/sPOc5zQWkM6MFvH53TE2xUSxSNHEGFqtcqJWFeOLIfKjcyj91xMA/00shBD5Qu4NNLrIwR5E33o6yj1LbbyAzcc2budTKzeyvKqKLaV+h4cHLC8Jc2hbjIOjCfA8qtpjjN/RwPitO/Asi7aKUhwHxu1oIRWwaS2LUJqIE4kmqNoao7QthXI9lOePUSkmljlDx6OSHZTSRMOEQzn8o4ux5YaHQox0g5b+aFLXdfm8r/TuyutUS75mVoQYcX74uWI+jMaYvzTJisoyTleQsnNPzQXCAT5wI0xpixFxXeKhAE1lJXjKv5x+6Zgg+0TbadvqUtEepyQaw1MQSDgcf88xjP/iJAJlO42yAMCJp7AjQSYOze4KIcSQkczK6CIHewjc/HycW56NERhTxLhYgjHNKYKOy5bKCE2RABWJFJbjctdxLhf+8xgsa+cfPPPuf4LYvQlC22Hs0WP55J/PGIY9EUIMskHLdjR2y6xUSWZFCJHr5jMjPLkszeKYYnNFCZsryF4gzoqn8NIevzsvwKnH9H4KY3CCTfDWYmbOlHtjCiH6r9AG2BbMReGEGEkWXV3Kx6rovIotMHZ7M6XROCtvKttloCKEEKIrCVaEGCRLZoeZdQiUplJUeWm+dHIJjXdUUVY86BcrFkKMeoV1uX3pBhJiED04M8iDM+WsHCGE2BMSrAghhBAFptDGrEiwIsQItfWnKR78j3kATPz0eD5z7yeGuUVCCDE8ZMyKECPQ1p+kYFXn8/XPbeEvFy8YtvYIIfKLf3Xrzke+k2BFiJFozc6zNr/SsPNMIYQYBSRYEUIIIcSIJsGKEEIIIUY0GWArhBBCFJhCGKeSSzIrQowwjSuae1226OfLhrAlQggxMsiNDEcXOdh54OGj/0y6xdltua+vPBcAz/OoP+nXtL2xmYCdZv+HZ1D8pWMHu5lCiD03aOmPrerGLp/31d5teZ1qGRXBitZ6AXACkAIcYDVwhzHmj8PZrmFQ+Ad7iPzqT438eX47ntOZnnRzlvc1ZXnzv1ehP1bSZd6DU+b1beV4jMMatjEluYKxzhYSlLKVA/GwUXj4ieAUNm2kCRM8bj+q5l6A89ZGis6ail0U7mMrhRCDZBCDlZu6BSu3SrAy0mWClReMMbdrrQPAVcDdwKHGmJXD2rihVfAHO+V43Pu2x5aoSzwNz66Gze3QkOjDyh1/C56H5XpUxlLs25YgEbDYXBqmLRKkOJ7ilLUNWPjBiYX/aeOxB586nseR7duYbNb0rw7PQ295nyPb38IhwCYOxWHnAKSELShc4lQQJEGcCGPZQJIwLiGKaSJNiFbGkKKEAAkCJEhSikeaCrYSoZko+xClApskTrCEEruJEm8HXkUZgS8fg1UegSvPgvGVJN/bRvvdLxPYsoXSCw9Fffoo+NkzUBKGf/ssSKAkBEiw0mejboCtMSattb4f+BFwFLBSa305cDUwAVgOXGuM+UfHOrtarrW+GTgZMMAs/O+vO4DHgV8DxwArgIuMMcsz63wJ+B4wEYgC840xFw/uno8OV7/ocu/bA4zJlMr+f+COVg7a0Q7AhvIIbZEgKMURW1vpuA1h7u0I9+hTQCneKdmHivLtjG1p6/tqrktVe4JXKk9hY+kYShJpDtm+BbvbD5B2xmen0xSzL0vxsGiihhqWZ7Iw4BCmmQrSBEjTke0J0coEIEALNdk6VMqhLLURmzRsbcf9ydOAB4+9hvO3O9hy4sO4zUkA3GfmUrHfb2BD5joxi1bB7785oJdKCNE3hfbLdNQNsNVah4DLM09XaK2/DNwGfBUYC9wPzNdaT8qU3+XyjFOAD/GDmYvwszYPAlcCY/ADnP/J1FcM/Aa40hhTBtQBDwzW/uZqbW0t+OlX1u9+rEdf7N8cy07v1xLHyvzlV8VSe6X+nShFQ3lpv1YZG2ujIVLF+2NraQmXsqm8krWVY3a7nodFjAoCpLKBCkCAntNPDhES5LZNYZPyA5UMq6Oe5etJvbUhG6gAJCjpDFQA95Xl2emR8J6RaZkermnRd6OpG+g4IAGU4Y9dudIY86DW+jngTWPMd3LKvwY8aYz5fh+W3wx80RhzeM7yrcDdxpi7M88/CzxijKnKBCvbgW8BvzfGDOVlSQv+YN/yqsvNr7q7L7gbx9Y3sE/U/8JtD9osqBsHSnFc/Q7GRfd+wKJcj9PfWkpFe2z3hTMO3rqRkOvx7oT9svP2b2rg4B1bd7neRBaTpIRtHMgE3idEDBeLrUwlQdlO5QO0U8EWdjCZzk4vlxreI5gJcFyUH7CcfBju0zeycdqvcNb5H8pjWUPpx4rh3Xq/wqvOgp9e1uf9FKKADVrXzGb1vS6f9xO8W6QbKE/ckRmzUoWf9Tg98//+wB+6lf0oM58+LAfY1G15tNu8KH6QhDEmmglergHu0FqvAv7bGPPogPZKdPG9Ey0+Ph62RiFkefx5pcfaFljRAM27izEygbvyPJaML6OuIUrA81hTWYSdTBN2YXvIpjyaIkDnp4zDHnYJOQ6fHRclYifpT5jVFC7i0B1bqYxFaSoqJpxOsX9zY/edyrTJwSZGmDa2cCBjqaeKtWxnP4poxUOhiGGjCNMKWCQox8OlxG4i4MWpdNcRpYpgOIVTMYZY+VTcRDNuzTiKZmdusnj+J7CKwuz75teIPvw2wS1biHzhPJg+Gf7wCpRE4Nzj+/sKCSFGudEUrABgjGnUWl8KfKS1PhtYBxzQrVgd8FRmenfLB9KGBcACrbUN/DPwuNb6DWPMRwOtU3T63IGdvZsXHb6LgrtV1Ou8LdsTPPlSO5Mm24wLwk0/acXBD1QcOvtXd9XPGrTh0R/vS1FRR6hzKND3s4G2lJayT0sjR2yqx7UUIcfDwsuEJ24maIpihz1Kb/wUZVefgl3SObA1DD3kUXoXASr6WNYeX0rZt0/qOvOrp/dja0KIPVFoF4UbdcEKgDGmQWt9D3An/mDYn2itnwQWAV/BH3j75Uzxh3azvF+01uOBk/DPTmrWWjdlFu2dwRZiSIwfF+ay8zq/+J9+oK9f47tnVyic5l332NlVikvePD/7PLWjjR3ffp7wIWOp+PdPYIXsXawthBD5ZVQGKxk/Af4DCAG3AL8FxgMfAJ81xqwFMMY8qrUe09vyAbDwB94+kDmNeh1wsTFmzR7siyggZz92BvPOfL7HZaf+5ONM+adJO80Pji1lwoPnDHbThBB5o7AyK6NigK3IkoOdJ3rrCuq4aq0QoiAMWkSxSd3S5fN+X+97eR29jObMihBCCFGQCm3Myqi7zooQQggh8otkVoQQQogCU2h9/pJZEWIECvdwrtk5z8qpv0KIvvFQXR75ToIVIUagimODlFzR+fyLCz7NmAOrhq9BQggxjKQbSIgRqmRqkC+tnDnczRBC5KX8z6bkksyKEEIIIUY0yawIMUzUDzvvWnz2ZHjiPPlzFELsHYUwTiWXZFaEGAa5gQrAn1fDna+keykthBCjmwQrQowQ33ltuFsghCgUXrdHvpNgRYgh9qnfSQZFCCH6Q4IVIYbQX9ek+duG3pd/7emugcxrd77Dg1Pm8eCUefzfZS8NcuuEEIVCrrMihBiws3u+P2HWQ+93Tm+7N8V7cz7KPt/04g4/cJm2m0qEEKLAyOkHQgyR0h+mae9DuVjK72H2PuylQLzzrszn//0zlNaU7J0GCiEKRiFkU3KNmsyK1nqN1vqi4W6HGD3e25am5J406of+oy+BCkBRsO8fMnNPeZa/ffONgTVQCFHAVLdHfhuRmRWt9QLgBCCVmbUZ+Jkx5sd9XN8DTjbGvDw4LRSiZ57n8fwah888PuAKAIh9lNpNwU6rn1jPg0+sx3KSTJoQo7K9EddVlBIlMKGMCV4TpV4arv1n+OwxA2yYEEIMnxEZrGTcZoy5HUBrfTzwV631MmPM80Oxca110BjT928MUdB+v9zhOy97NMSgKTl42wmmHL74+aV8Zmk/fgspv6Rrhxj/3jsc3roCD1hXtC+BlfWUJLcD4C1Ytutq2PkUxz36PWYrcLzOimwL0m7XMpYCt4cTKzs2bFkQCUI04e9neTGkHX89x/X/b413XS9g++sFbSgOwfhKmDgWNjbC0rVg2/DTS+HSM+CeJ+HtNfClk+Bz2t/ObX+ERav89h5/EPznuRAMwJqtcPPvYUk91FXDt86G4w/2t7u5EW79g9+m73wBaveBTQ1w6x/9AHTGdJj3OhxQ7S8PBzvb/I/34P7noW483HAehHKWCTFAhXC6cq6RHKxkGWNe11q/B3wMeF5rfSfwJaAa2AL8tCProrV+J7Pac1prF/i9MebSzLxarfVfgeOANcC/GmNezaz3EBDEz+b8MzAXuFxrfTlwNTABWA5ca4z5R0fbdrVca30zcDJggFn43W53AI8DvwaOAVYAFxljlu+t10vsXSsbPS74izckf/xKwUkfrh9YkKAU74yZxuGtK1BAbWwTHp3f+32pc68mi52cV8xj50AFeg5UOsqD/+XfnsjM86BpN51pHpByAAcSKWiLw9YWeLc+p11p+H/3wY5WuOERf97vX4bF/w0/fwZ++Vxn2WcWQSoNt10An70dlq/35y9eBc+9A6t+AePK4bz/glc/8Je9tgKW/Ag+fxcszAw8uv/5zn2NJuCHl/jTGxtgxm3+PIBEGr4vvdVCdDfix6xorZXW+hPAIUDHZbPeA04CyoDLgO9rrT8DYIw5MlPm08aY0pxABfyA4RtABfA88HC3zX0ReAbYB/im1vrLwG3AV4GxwP3AfK31pEzbdrk84xTgQ/xg5iLgbuBB4EpgDH6A8z8DenH6qbW1VaYHML1kY3TIfqWUxpOUJgae0Eurrr8/8r+nehC9ubJz2nFhxUbS767Zudx762ltboYPNnad3xqj/YP6bJms5etpbWmB99Z1zssNyjJlW1tb/WxNR6AC8N66EfGel+mhmR5Mcury0PmO1roJaAdeBh4BFgIYY35rjNlojPGMMX8D/gJ8qg91/tIYs8wY4wAPAFO01hU5y182xsw1xjjGmCjwtcw6bxhj0saYB4ElwAWZ8rtbDrDCGPNAps5ngB3As8aY5ZlupkcBPaBXqJ/KyspkegDTZ04tZkyEIdFYWsTymnEDXr881cqOUGXBpYD3ulAA/v2fIBLyn9eNh9OnEbjs013LBWz46mmUVVTApd0+Yo4/iJJjMt1Al57ROX/WJykrL+86rzrzMWNbcMnpQOY9dnSd/+hYdvHpI+I9L9NDMy36biR3A92RM2ZlIv6X+hzgYq31N/AzKhPxfzwWZZbvzqac6Y58chnQnJle0638/sAfus37KDO/L8u7bxMg2m1eNNMGMUKVhRSrL7N58F2XWNrj2TWwogFiaWjey+NXPGDN2DLqNm0n5PUjM+J5WJ7LjlAF75VN4YQdbxGzI3jKIpROECCNApIESSuLIi+BBTiATddfLSn87Vr08deMDRSH/bEgrXF/HMlJB8PkCfDMYigJw/7jYMoEWL4BPtwEAQXT6/wum0TK/6Le3grbmqGqBA7dDzY0woRK/8v8iYUwuRqmH+iPBSkr8rtxpkyAx14Dx4GQDWlg+mQ/GCkKQWkRTJ0AFSUQT8Kv/+aPe5lzJYRDsOzHfsbkhIOhsgQu+aS/vdVb/HEvU/eFQyb6+/nLy+GiU6F+m9/1c+rhneNL7r4Yzj7Wz9Ccerg/70ez4Nzj/e6rY6bAS8v81+Hw2s7XLhKCf9wBf18Gk6rh0Il9PeJC7FIhZFNyjeRgJcsYs15r/Qf87p5fAXfhZ1LeMMY4WuvH6Pq5PtAflt071dcBB3SbVwc81cflokCUhxX/oW0Abjh+9+UbY2nG/HwAG1KKP8w7ir88vZ6t/9GP7iCluHDJOYRKOv+ke4qAi7o97ykYGZHDO7/7L70vu/acvtdz7gldn9dN8B+5jjjAf/Tk5MN6r/ukQ3ddfsbRPa9XHO59mRACyJNgRWs9AX88yTtAOf4Pwm2Ap7X+J+As4I85q2wGpuJ3H+2Jh4CfaK2fBBYBXwGOAr7cx+VilKoqCuB9y5+OJdJU/LTzPPxdsdNpHNfu17YueOOzFI0don4qIUReKLTMykges3Kj1rpNa92GH6RswR8L8izwv/jjV7YDXwD+1G3d7wC3aq0btda/HGgDjDGPArcAv8Ufa3I58FljzNq+LBcCoCgcIPmtAH/fRXKgQzDtknR2nxgsnRTh49cdytdXniuBihCi4CnPk6F4o4gc7GG238/SbIz3stDzOP6Ddbz2QB1PPfUUUZOi7ZGdi8184hSqpw18EK4QYsQYtPTHh+ruLp/3U71r8zrVkhfdQEIUile+YjH5/h6uNwLsu6OZn9xQk31erIOcf8tMNr6xlWBZgH0OGzNUzRRCiBFlJHcDCVFwDqiwWH1Zzz9wNo2r5Ni6nbt0ao6rlkBFCNFPcm8gIcQeOKDCxj/HVgghBocMsBVC7LEje0iUPPH5oW+HEELkA8msCDEM3p4V4I0Nab7wBJSF4c/nwtQx8ucohNg7Ci2zIp+OQgyT4/YLsO7K4W6FEEKMfBKsCCGEEAWm0K5TIcGKEMPsjjvuyN6Jtaqqiuuuu26YWySEECOLDLAVYhhdf/31XW4Z39jYyPXXXz+MLRJCFAIP1eWR7yRYEWKY7CooeeWVV4awJUIIMbJJN5AQw6C+vn64myCEKGCFkE3JJZkVIYZYfX099957727L5XYPCSHEaCbBihBD7OGHH+5TuSVLlkgGRggxIF63R76TYEWIITR37lza29v7XP6+++4bxNYIIQpVoQ2wlTErPdBanwa8YIwJZJ7fDJxkjDljONsl8t/ixYv7Vd51Xe666y5aWlpwHKfXcpMnT+ass86itrZ2T5sohBAjTsEGK1rrOuAu4GSgFGgEDHC+MSY5TG0KAdcAFwBTgHZgPfA48DNjTNNwtEsMvp///OesW7duQOs2Njbutszq1auz42CCwSC33XbbgLYlhCgMhZBNyVWwwQrwf8BzwMFAC7Af8DmG4V7ZWusg4AJ/ybTj34FXgShwCPB14GPAP4a6baLv6uvrWbRoEQCRSISNGzdSUlLC9u3bKS8vp6WlZcAByd6USqVGxLVabNvOZoNs22bSpEnE43EaGhqwLAvXdXEch0gkQiwWo6SkhEMPPZSjjz46myGqr69n1apV1NXV9Tpv4cKFLF26lJqaGiKRSJeyA9XTdoUQw6cggxWt9Vj8IOVcY0xzZvZ64L6cMp8HbgQOBDYBtxtjHulj/cXArcB5QAWwELjKGLMys3wB8DZwAPBJ4E5gA36W53BjzEc51S0HvjWQ/RRDp76+nvvuuw/XdYe7KXkjt9vKcRxWrVrVY7lUKgVAc3Mzr7/+Om+88QaXX345QPY1tyyL2bNn7zTvlFNOYcGCBQCsWLECIFt2oEFG7rHe07qEGC6FMKg2V0EOsDXG7ACWAQ9orb+qtT5Ma53NqGitzwQeBK4GxgAXAz/TWp/Sx03cj58ROR6YALwBPJ3JoHSYBfwPfjDzP8BZwJvdApUhlXsqrEz3b3rVqlUSqAwRz/NYvnx5l9fcdV1WrVrF8uXLu8xbunTpTut3lIU9P9YddY2U96FMF9a06LuCzKxknIY/PuRqYBrQpLX+KXA7fjfMT4wxHd0uC7XWvwW+Cvx9V5VqrcfhjzmZZIzZkpl3S2Y7xwEvZ4o+Zoz5W2Y6qrXeBz+7klvXq8BhQBD4vjHm9oHv7u6VlZXJ9ACn6+rqsl0XYnAppTj00EMBsq+5ZVnU1dUB8NJLL2XnTZs2LZtZ6ZBbdk+PdUddI+V9KNOFNT2YZMxKnjDGbAduAG7IdNv8C35GZAMwGThda31Nzio2fRszMjnz/xKtde78ILB/zvM13dbb3m05xpgTAbTWL1DAx6IQ1NbWMnv27LwYszJS7I0xK7Nnz95p7Ej3eWPGjNmrY1Y6jrWMWRFi5BgVX5DGmCjwkNb634CjgLXAQ8aYuwdQ3drM/1ONMdt2Ua77T/BngF9prQ8czq4gMXC1tbX9/uKqr69n7ty57NixY5BatXvFxcWUlpYSi8W6pKCLi4uZPHkyp556ana/OgarTps2jWOPPXa4mpzV02vefd6xxx6719s6kGMtxEgimZU8oLWuAr4NPAJ8gD/W6Gz87qAfAE/jBy+v45+VY+OfjaOMMWZXdRtjtmqtHwXu1VpfbYzZoLWuBE4HnjfGtPWy6qPA14CntNbfAF7DPxtoKlCzRzssRqza2lquvfZaAObMmZMdBDoYqqurueaaa3ZfcBcG44tfCCH2VEEGK0ASqAbmAfsCafxumW8YY/4IoLW+DLgb/6whF39A7k19rP8y/C6mBVrrCUATfhfSc72tYIxJa61n4J/582P8s5DagHX4QdUv+rWHIu/MmjWL733veyQSiX6t94Mf/CA73dP1WnKXCyEEFN7ZQMrzCm2XxC7IwR4B+nMNlOLiYm66qa8xtBAizwxaX81i9bMun/fTvavyul+oIE9dFmIku+KKK/pc9pJLLhm8hgghClah3RtIghUhhlhtbW2fApYjjjhCBnkKIQZIdXvkNwlWhBgGfQlChup6DEIIMdJJsCLEMNlVduUTn/jEELZECFFopBtICLFX9NYdJGf3CCFEV4V66rIQeaG2tlaCEyHEXldop35KZkUIIYQQI5pkVoQYZu1vbWLjj9+m5pvTmXfuP7BjLqmQjTrVhpnD3TohRD4qhHEquSRYEWIYvX3I/WxbD4GExdsvtOHa4IYtXAVblxbzlQs+xFOKfbw4P3p02nA3VwghhoV0AwkxTDbe8zqVK1cQjCkWHncwH02ZQKokhGfZuLbN8oPrULaNsizWB0s55ysfMmfe8N0QUQiRP7xuj3wnmRUhhkns208Sd8bQVl5Ee2mYg95bg5W5/UVraQQ3YBNwHBT+h83b5eUseyHNL+ZvIFUR4O27xw9r+4UQYqhIZkWIYdD299U0hUpopYyx0UaOXf02FcmW7PJgyiWUTlOcTlOUTlOSTGJ54FkWDeEQ22IW9s3tXPjH2DDuhRBipHJRXR75TjIrQgyD9WfMYVKqga3YHJx+F3uFS0rZPFd9Gk3BcloriylNJEgH/D/RHaEgKUuxsbKYRNCGiA224tE1Hr+7tQ33ptJh3iMhxEhSaANsCzKzorV+Rmv97eFuhxA9WfuF/6XZrmD+AaeRrExh4wIQ9ByqE1tYP2k8LWPKCaXT2XXWF0VojwT9QMVW/gNAKQLBAEdetYW1O1LDsTtCCDHo8i6zorVeAJwAJAEX2AG8AvzYGPMWgDHmrD7WdRrwgjEm714HkZ9WjLmBssZ2Pqr5BGUNSVq9iuwyD9hcOpZkcRiA0ngC5cHyqgq2BQNYbmaYnOf5D+UHLCnLYkkkzNTbWqE0yC/ODXP+tCClocL6ZSWE6LtCGFSbK1+/pG8zxtwOoLWeBFwGvK61/hdjzJ+Gt2liVInGIZaEHz4BTTFoboVn38FraCcNtFNOCxWU0kzQSnOgG+fdsKa0zc+CNKqxvFR5AnVNG2mgim2hfXHxU54KCKXTVDouB8QSbHFdHFuxvSiM57oQyCRGHQ/SLimlIO1x2Z/TzH46TVpllgWg2PNIWRb7lcKvPmcTTyuqixXTqhXhgE3AlsBGCDFy5WuwkmWMWQt8V2u9L/BTrfUTwIv4GZPbtdZh4KfA54EIsAW4AT8b8wxga63bMtVdaYx5WGv9a+AMoBJYB9xujHkUOrMxwIXAncA44Fng68aY1kyZfYAfAGdm6lgJfNkY84HWuhi4FTgPqAAWAlcZY1YO1msk9oKWKMz6GTz7NrTFd1tc4f9xldPGuv/P3n3HyVXVjR//nDt1y2xJr5tKgFCFQ+hNiihNUPQBURDpigUF8REQCwLCT5QHfVBpKk1EWkCKlCDwSDmhJwGSLMmm1y0zu1PvPb8/7mQzu9kkk2Q3M7v5vl+v+9oz59577pmZ3dnvnHaZwifsQY23lliolWSVJZJJkXaiAKwMDWUci4lTTzTrkQmGCFgPVynWVlUSAsanM4xPZ1iRTPPkkDqojoCbDzBcvxuJihA4CutaclZBVRAyHrRn6HAthGFBLsCx93oQCUAqC1kPqsPgKLCWYHuWiOfRnvX8fdEgxCJ+S07W9Z9ZwPGvGXb881CQcyHpgoJIVFHjQLsLU0aH+OE0xdf+niHrWkJRh/87J4IeOSB7oIUoGzJmpXw9AIwGdu6WfxawH7CrMaYG+DQwyxizFPgs4BpjqvPbn/PnvALsjR9o/Ay4W2s9taDMAHAssBcwBfgU8G0ArbUDPJ4/d7/8z7OBeP7cPwG7AAcAI4DXgSe01qFeeA1EX7nuYfjHa0UFKusoYAWjWcMILA5RUkzOzuHAtW9ySPJFAmTJhALslXqLkSzC4jBqyVqGrmzFVQ7pSIRMqODXwlr2Xbqcw9e2gLP+T1cptf6CBcfiAfG0H3SEAlARhmDAPzeX70aqifgtNI4fhORiYTLtWUi74FnoyELO8wOUYMAvx1H+T5RflqP8oAjAQjppWdVu6UhZ3lmY46tPemRzFixkkx7HPyhja4QQW2YgBSuL8z8Hd8vPANXAVK110BizyBgze1MFGWPuMMasMca4xpgHgPeAI7oddoUxJmGMWQE8Cuh8vs5v5xhjVhhjPGPMe8aYpVrrIcAZwMX5fRngp8BIYP+te9rFi8fjkt7adFsHW2d9z/FgVnSmq9wOhmbWMCm+gCnx+URIM4SlBDzLmMVrOtdbCXpe5znhXI6wZzlo2UpCrrv+CpEAjIqt7xYCv+UE6wccpJ4UQAAAIABJREFU4Acb6yjl5yvFBl++lNqwrztfl01+UdtYB7m1eN2ykpn1B5fN+ytpSZcg3ZcsqsvW3/X7bqACY/I/uy/xeQ8wHLgZ2Elr/Txw+ca6XfItI9cAX8Zv+bBAFTC04DDXGLOq4HE7EMunxwMrjTGtPRQ/If/zPa11YX4IGLuxJ9ZbYrGYpLc2/f2T4MmZsLDwbe+ZZf3/9eEsYS1DWcVIVgcHMSy3DIAcAbxUBI8ALkEC5GgeGuTD+sFkAwGUtYSyOWpzLomKCKFcjkGJdizgBYIcvmgVr44eQrIyBEHlBx6xMKxM+N1B0aAfZFSG/NaRTA7CgfWBiqMgmQXPg6pw54Bdpz1DbUCxxuKPd4kE/POshYzrt6QEHb+MUMEHYCQAyfzspYDyzwUi1UEu3htu/nf+hQkqfv/Z9R87ZfP+SlrSJUiL4g2kYOXLwBLgo8JMY0wOuAG4QWtdB9wK3AkcBht86QM4HTgXv5tntjHG01obNv29stACYJjWusYY09Zt38L8z526BTui3E0cAY3/C60dkM3B6lZ4fS48+x68+B6sboN8Y8cixlBLC1HaCWKZwjtUOat5ZdQBrO6IMSaxipGpJYwOzGV2eG/eTx5IB1Hi7RWoWkt8UDVuMIgDONbiZLKsroiS9jwqrSIXDrFrvIOhnyzj/j3Gdc4KwloYXOm3onie39VjLYQcP5jIZMGCcjyqPEtN0FJXH2JaQ5Zh1YqRIZd5a2HnEVHG1wYZXwc1UcXalMeaDhhTH6YupFid9HA9xZAKxcoOGF4N1gapDgdpTsKwmEPOhZy1VIUUkaDihiODzFntsfOQAJFg//+WJ0S5k9lAZUZrPRY/uDgb+LIxxha2WmitPw204nflJPFbQda1oS/HH2A7wRjzST6vBsgBqwBHa302/tiUJ4qskgHeAm7XWn8LWA3sDqzOdwXdB/xea/1dY8ySfAB1JPAvY0xi48WKknMcqM8vvjasDqaOg68fvcFhDd0eB/Cb20a918Qzxz1BvbU8MW4vRjevJOMG8QgRI8PSmlq8gEOqqrLL+Utj1TTFqqC+ltpMht1a/V+TIeksgXQWNxDIjzvBbx3J5rj+YMtlh1UAkW1+2uO6PR5RE+hMj67ruq+2Ip8IQWF8Hwo67DliIPU6CyG2p/766XGV1jqutW4D/g1MBg4yxvyjh2OHA38FmoFl+J+95wMYYz4G/hd4Q2vdorX+KvBn/EGv8/BbaqYCLxdbMWOMB5yIHxi9A7Tgt+SsW2L0PPzWnxla6zjwPnAaAy8QFt2E92zgxKUXE68OEo9UMXvEBAblElSTJkION9+tEsqsH4DqASsqo52PW8PhzubABVVR3Ja038WTznHRzllSlwZxfxTNBypCiB3VQBuzoqyV/5E7EHmzy8Qjw+9msGpl8opVJKgHYHVVJbNGjcANOLTW1dBeXcna2mrm1NXQGg4DfpNfIuDg5HI0hsO4tVHIWdqvjlAZlQllQvQzfRZF/Fvd0eXz/jD7jX4dsfTXlhUh+rVDbz2YMYllxGhD5XslaztSDF/aTnVrmkgqw7JBdTieZVK8nREdSYYm01Qm08yvq2TukBrcmjABPJI/rZRARQjRxUBrWZFgRYgSGHLaTsyvGI/CZTQLGcwSPhgxjGUNNSQGVeCFHLLBAK2VFXiOw9BMlozn8t6gagIKwtbD+1k1uZ/FiIbkz1gI0ZXttvV3/X6ArRD9VX2t4tXEPqACTMg2Miy7io5khFwoQJXbTl1LG2vra8kEgyjPIxtyOGIiXHRMmOOnSEuKEGLHIcGKECWi513AcxV/wHMDzA3thBO3qGqF5yhygUD+K5HF8TxCuRz/vndyqasshOgnBkLXTyEJVoQooaOTF2C+9BytTy6iZv963nHr6aiuJJTOsuvahXzuts8xbHiQSCSw+cKEEGKAkmBFiBLTD65fq2W//M/p06cDQcY2bPs6KUKIHc9AGKdSSEbmCSGEEKKsScuKEEIIMcDImBUhRJ9JJXNc+LU5LIntRdjzeObRR7j1jlNKXS0hhCgp6QYSooxccua7fDBkKM3RCCsqK2i0+/KDi28pdbWEEP2MLAonhOgTq1eliQcrcYCw64G1ZBwHp3GvUldNCCFKSrqBhCgTN5z1PmMcRTgUIgC0BxycrEesOVfqqgkh+hlv84f0K9KyIkQZSCVdarJZckE/UMFaqlyPEa1ttFWFaGpqKnUVhRD9iHVUl62/k2BFiBJzPcvBFzWRUgrPWsI5j7BrcTy/t7k9HKSxsbHU1RRCiJIpm2BFa32b1vrWgscLtNZnbuL4K7XWMwoez9Jaf7mPqylEr7v88vnEAkGemTyB1qoqFP5940Oux5L6etxAhIkTJ5a6mkKIfsSqrlt/12tjVvKBw4FANp+1HLjVGPObYs43xly4Ldc3xuy2LedvjNb6K8A9wDXGmJ/2xTXEjqetI0siB+fesJLm5gjZSJjBqTSjm5upyGToiERpjlVTl80SsLB8+XIaGhpKXW0hhCiJ3h5g+3NjzC8AtNYHAM9rrWcZY/7Vy9fZni4A1gLf0Fr/whjjbuxArXXIGJPd2H6x47DWsrglw9MfZZi9BH7zDkTCAVzXknOhMpkhGQqCF2NkVZox6Rx7rlhFXUcSgEiuHU9BKhSiYekKGo9dwaLMLAKOZVCgg+BeQwiv7iATcqgYFcWZ20zMTZAdPxLVuJLKqg7c/SZTFfao/NKeBKeOxF26lkAqi13TjsLi7DQSmhMwYTiBIVXY1nacumqs62EDQZTrD+xV0fyS/0ph21PguahYFdZaVCaDDQZRjgOuC4EAKAWeB07ZNNwKscMZCONUCvXZbCBjzGta69nAHsC/tNYWONQY8wqA1voI4DljTDD/+G4gZ4w5t6fytNbHAzcCDcAMYF63/QuAK40x96wrG/gK8EtgCPAM8A1jTDx//BTgT8CngE+AO4HfGGNUQZm7AocCJwKPAJ8Fnuh2zTuBI/Fv63Ku1voh4HLgbGAYMAv4jjHG5M85Kl+nKUAOeB74tjFmZREvqygzv3slxQ+fSJLKghsMQMiB6jC4lrr2JK2hCFZBfTZL2rHkUOAoOiojoBTVqTQT2xJUeJbqTKZL2dGcSyzRQSoXoDoZJD44DI5iZbqCIS+34+ESo52x7y1hDUNIEaR2wXyCuCg8qua8TJQk3u3PkyRGDqhmJRmGEMTFksMhTZA2LEFcKoEECg9FEPyhvlhygIuFztUa/PuO+EcqLHYjdyJJMBqASpbiFBxjccgwGEWWMK0oLASDkAtCfQUkU5DLYnNdZ0KpaAhSWaiKQDaHVQFIr3/dvGA96pJjcM4+AE79FSxvgWu+BD/4vH/ATY/CNQ/CiDo4fhrc/jKMroeHvwO7j11/obuex37rdkjlsJW1qNvPQ315/03+Lnh/eQV1zv+Am8OechDOw9/f5PFC7EiUUscA/wUMs9aeqJTSQI219oVizu+Trz5aa6W1PhjYBfhPL5Q3CXgY/598HXALcN5mTgsAxwJ74QcGnwK+nS8vCEwH3gWGA6dspLzzgfeMMU8A/8RvZenuPOBSIAY8BvwUOBk4DhiMH8w8rbWuzx+fBr4FDMUP5EYBv93McxFlaG27x7cfSdKeAdcCOc+fL+h6EHLwrIN1FLFUltb6KB0RP4wA/NYHIBGNsGdrG/uuaSYVieDmWyPSgQCrq6vwAg57zltJujoI+W9K2UiAdDiIh0M7VbRQzzBWUUGGUP4KAXJE8VtpHCxROoAIHtWdx1iCWEJYgjjkcMjhUYVCoQjmfyoUgfxGt81i88HKhvv8rZIVWAIEuh2TI4YlvD5QAcjlAAvNcT8gyeU2KI9UvuGyPQ0ZF5XOdD0mF8fe/C/suX+A+cuhPQWX/xUWr4Yla/x0e8rfd8sT0JGGucvhsvvXv7HJNJx/G6ojjfJcVKIFe84dWG8zk0G/eTvKzfqtVo+8ip0lM7hE6Vin61ZKSqlLgP8F5gKH5bOTwC+KLaO3n8KPtdYtQDvwCnAv8EYvlPtfwBvGmHuMMTljzLPAo0Wcd4UxJmGMWZE/XufzDwDGAz80xiSNMY3AzYUnaq2jwNeAu/JZdwCf1VqP6XaNPxlj3jbGWCCFHxBdZoxpNMa4xpg7gGXA8QDGmFeMMW/mn8dy4FfAUVvyYmyteDwu6d5MJxJsSmc7ggIv4PR4G9Sg51GRc3EA6zi0VlfRXBPjw6GDWV5dRdJxyIUcnFzBP0prcdz1hXn+2d2urTb5uFsNu9mSY8uUUhs8Tmzq/cof3/n+djvfqh6O6ZbeoHVJOZs8XtKS3oF8FzjaWns965eA+RDYudgCejtYudYYU2eMqQTGAlPxWxa21RhgQbe8TzZzjmuMWVXwuB2/9QNgNLDSGJMs2L+w2/mnAdX4g2vBb1lZBXTvpiqs15D8OdO11i3rNmBi/jmgtd5Xa/2M1nq51roNuB+/laXPxWIxSfdietzwGm49tZJYBIIKVMDv4iHgQMbFdUBZSyIcJJLK+V1Enf0olopsji/MW0RVzsVay/JImGQgQGN1JR8PqiNiPZqjYZ7ZfwIuikDKJZh2qVubJuS6OHhESFNHM6sYQpIQuXxni0eADqrxcHAJkKGCEG0EiJMmlP+36qHIoMjhEcQjhEMHFg9LLt+5Y7G4+Ty6baqzdWXDff7WznAULm63Y4LEUWTIUOefr4BQCFAwuAYqwxAMdi1PARVh//WrjkJFGBsNdz0mXIv6/rGo2y+AKaMgVgE3nQWjB1O98zg/HauAnUbCd0/yy9l5JNx4+vr3tyICf7oIWx3FOgFsrB7nrnNR+WBlY78P6g8XYINhLArvi4eipo4p6e+npMs/3ZdsQHXZSiwGLMqn10X1ISDT8+Eb6ssxK4u11g8C1wFnAQmgquCQUVtQ3BLgM93yxm9D9ZYAQ7XWFQUBS/epFufjdyV9oPW6Bhnq8Afa/rxgoG1h2/Bq/KDoaGPMmxu59gPAQ8Bpxpg2rfUJ+F1Soh+66OAIFx0c6XFfWyrAjHlZHnyrlXvnRYm4EQanM2SVYlUoTDLgMHNwLZOb24gHg7w6fAhWKUKex+6JDvAs1e1ZqjvSfDi6jj3nLyUTDpJUGVbtHKfehmju8FgWHsqwhENHrUeTCjLWiRBrqMVdGydz5n5EDx5LtGEI7vI21IR6KmYuxKuOEAiGIGSxE4ahAg5B10OFg+A4/uBZ/F9uBaiA3w1EzvUH0kbCWGtxCgfSrmuNsLYzXbOR100B0SJe3819xHbfHyh88NGtbODSk/xtnZu/1nPBZx2JOuvIouqwjnPGQXDGQVt0jhA7iH8DVwDXFuR9G3ix2AL6LFjRWo/Ab514N581EzhLa/0ifqBy6RYU9wBwtdb6dODvwBHA5wGzldV7DWgCrtNaXwGMxG+mWlf3qcAhwElAYdAxLP88PkcPAYYxxmqtfwvcpLU+1xgzV2tdDRwMvG+MWYr/+d0KxLXWDfhvoBiAaqIhTto9xEm7V3Y2z73xxge8+eabtLYlaW3PMd07gJeHN7DvmlY+07SUZTUx6rI5hre0MmhNM821tSQqwux0zsecdEFPQ6aKFxqW/0Z3xK6bPXbdP9sNml6DAX8Dv6UhEOh+xIZdMEKI7c4rr9lAlwDTlVLnATGl1EdAHDih2AJ6O1i5Kv/PH/wWhpeAH+Qffwu/S2gtMBu4Gyh2DZZ5WusvAjfgz+B5Cbgd2HtrKmmMyWmtTwL+iN+10wj8lfWDfS4A3jLGdA9Ilmut/57fv7HWkJ/gR4yP5ce3tOMHR5fk958P/D/gSvw+u7/iBzNiBzBt2jSmTZvW+fgG4IBvLuTfVaM4tGkJQ7M5xi1ZTnUyBcDQllbmjKiisrKyRDUWQohtY61dppTaD5iG34uxCHjDWlv0LYyUtf1s4Fwf0VpfAHzfGDOl1HXpQ/Jml6FszuOUM+cytr2DhtY4Ve3JLlOE10YDTLpwGV/96ldLWU0hRO/rs+aPx2vv7fJ5f1LrV8qqqWVL7bB3XdZaH4I/S6cRfwrx5awfTCvEdhMKOjzxwM6c+JW5jG9pwws4BFz/C0dLdSWx9vh2G5QnhBgYymlROKXUIjbyZdlaW9TS3DtssII/W+k+/Bk8q/DHwlxX0hqJHVoqEOD/JjRQm04TSaUZ2pFk6ZBBTFzawT777FPq6gkhxNbqfp+/kcB38MejFmWHDVaMMffjTxsWoix86dCXeP6ZabRFwkzwPIhGGNSRJJULyL2BhBBbpJxuXmitfal7nlJqBvA0RS6KKjfvEKJMnHfe1xmW6mDXtgQV+bygtaQr2vnggw9KWjchhOhlaWBCsQfvsC0rQpSjmr0fJ/X2yYScAFhL1eJVtB/zGrvvfkqpqyaE6EfKbMzKz7plVeIvAfJU0WXIbKAdirzZ/cBVV11FNrv+5t2nnnpql+nOQogBo88iikeG3N/l8/6U1aeXLHpRSt3VLasdeAf4q7U2XVQZEqzsUOTN7iemT/eX8TnxxBNLXBMhRB/qswDiH0O7BitfWFW6YKU3SDeQEEIIIXqVUurTxRxnrX2hmOMkWBGijP3tb3/j7bff7nx8/fXXl7A2Qoj+ogzGrNxRxDEW/0a/myXBihBl6uOPP2bVqlVd8q644goJWIQQZc9aW/RMn2JIsCJEmeoeqAghRLHKaZ2V3iDrrAjRz1xxhdyoWwjRfyilapRSv1ZKzVRKLVRKNa3bii1DghUhhBBigLFKddlK7PfAPsDPgEHAJUATcHOxBUg3kBBCCDHAeCWPT7o4FtjVWrtGKeVaax9TShlgOkUGLNKysgW01mdrref1cplnaq0X9GaZQgghRBlxgNZ8OqGUqgWWAZOLLWDAtaxorWcAhwNfNsY8WJC/P/AasNAYM76Icq4BDjHGHN03NRWiZ8WMSXn66ac57rjjtkNthBD9URlMXS70Lv7/5eeBl/G7hRLAx8UWMOCClbw5wHnAgwV55+XzK0tSI7HDe/rpp5kxY0avlDVjxgwJVoQQ/cV5rF+t9zvAL4E64GvFFjBQg5WHgQu11hONMY1a6xjwBfwX6JsAWusgcDlwNjAMmAV8xxhjtNZfBv4bcLTWiXyZe64rXGv97fy5VfgB0cXGGDe/b0/gN8CngGbgTuC6gv3T8KPKXfDvjfBsX70IYts1NTXR2NhIZWUlS5cuJR6PE4vFSKfTzJo1i0wmg1KKUty2orAFJhaLUVFRwSGHHCL3ERJClNvU5YXWWhfAWrsSOHdLCxiowUoKuBf4BvBj4HTgJfw+snV+ChwNHAcsxA9antZa72SM+ZvWele6dQNprQ8DxgHDgUnAWOAN4N/AvVrrWuBfwK3AZ/FX5nsS/1bYN+b3PwXcCPwa2At/gFGq918Csa2ampq47bbb8Dxvk8eVw/214vE48Xichx9+GEACFiFEOVmulPo7cJ+19pWtKWAgD7D9E/D1fAvK+fnHAGitFfBt4DJjTKMxxjXG3IEfzBy/mXKTwNXGmLQxZh5+H5zO7zseyAC/yO+fA9zA+ijyBPy7Td5gjMkYY96kuCWJe0U8Hpf0FqQbGxs3G6iUow8++KBsXkNJS1rSG0/3pTKbunws/hiV+5RSnyilrlNK7bElBQzUlhWMMR9orRcCV+F38zyN38ICMASoBqZrrQu/FoeAMZspeuW6Lp28diCWT4/FH8BbWOb8fD75srvv/6TIp7TNYrGYpLcgPXHiRBzH6XcBy+677142r6GkJS3pjad3FNbat4G3gcuVUofj/y9+QSm1zFq756bP9g3YYCXvj/gtFz8zxrhar2sAYTV+kHF0vnWjJ1vzH2oRME5rrQoCkon5fIAlPewfvxXXEdtBQ0MDF154YdmOWSkkY1aEEIXKbJ2VQh/iT3ZpAnYq9qSBHqzcjx8ozCzMNMZYrfVvgZu01ucaY+ZqrauBg4H3jTFLgeVAg9Y6bIzJFHm9J/EH1/631vpGYALwQ+AP+f1PALcAl2mtbwb2wB9Xk96mZyn6TENDAw0NDb1aZm8tly83NBRC9AdKqTr8SS5nAAfgTyy5AXi82DIGdLBijEkBz21k90/wx608prUeg9/S8hr+MsAAfwe+DCzXWjv4s3s2d71WrfWx+Cvy/QB/EZy78AfTYoxp0Vofjz8A92r82UD/C5yzVU9Q9EubCzKKCWYuvvji3qqOEGIAKoNxKoWWAv8H3Ad8wVrbsqUFqFI3X4vtSt7sfmL69Om8+uqrG90vrSpCDAh9FlH8ecJDXT7vz/rkiyWLXpRSI621yzZ/5MYN5NlAQgghhCixbQ1UYIB3AwkhhBA7Iq+8uoG2mbSsCNHPBAKBUldBCCG2K2lZEaKfufbaa0tdBSFEmSuz5fa3mbSsCFGmJk2aVOoqCCHENlO+85RSLyil3svnHaaU+lKxZUiwIkSZGjFiBKeeemqXPJkFJIQoRpktt/8z/DXF/gisW7hqMf46ZEWRbiAhyti0adNkRVohRH93NvApa+1qpdT/5vM+wV/hvSgSrAhRrqyFnAtBGVArhNgyZdCaUiiAfyNDWL/eV3VB3mZJN5AQZWjQrXPZ6ZyZNA36b17a9yKamppKXSUhhNhaTwG/VkpFwB/DAvwcmF5sARKsCFFm1j78DuEPPCasWcnweBv7vhPgnutukYBFCFE0q7puJfY9YAT+LWhq8VtUxrEFY1YkWBGizCx9fiGDOpoJsYYwK4l6bdSsruCpp54qddWEEGKLKKUCwBfxb2LYgH8jw0nW2lOstfFiy5ExK0KUgf9U/QIbrMRTimhmNaO9xbwzehdygRC7L5tDdE0tCxcvLnU1hRD9hHVK35wCYK11lVK/ttbeCaSAlVtTjgQrQpTYYnUZi0bvTWtlJcpaBsXr+ffkw1hZPwyU4p9TjyHmzsHzmktdVSFEP1FmA2ynK6VOtNYWPUalOwlWhCihWeHrUMEhtFRVglJYFG1VVaSC/mOAVCjKIfPaeXePUIlrK4QQWyUKPKSU+g+wiPUzgrDWfq2YAiRY6SNa6wZgNjDFGLNUa302cKUxZnJpaybKRfvf3yOcTdOshjFyaQLrKlxHkaxTRLNp2oh1Hhty0+z27yRNTU00NDRsolQhhCifbqC8D/LbVus3wYrW+g78BWSOMsZ4+TwHmAHMMcZc0IvXOgJ4EWjPZ6WB14DvGGPmFVOGMaYJfx75xq5xN5Azxpy7TZUV/dbHX3qEDMNwbZBAyiNRH8YLOoRSLiM/WYPnOrTVVrO0roY/HnwSn539Ao2NjRKsCCH6FWvtT7e1jH4TrADfAd4BLgVuyuddDgwDjuuti2it17W1u8aY6nxeFXAb8BfgoN66lhgYckvjeM0pQlOHoJRi1UvLSK5Isvb1lVRWKNo+bKVy2TKaFliq2xJEEklygRAdsVFUxi0WSFcF8YL+5Dw3HEABY5pWMW9KmKM/fp3/jN+H6bscRdufQ9z41yZWVYb5cFgNjuvRGg6AckDhN6561l9QDiCg/Hzl361ZAeNikMxBPGWpjloSGRgZ8hhUoThqksNbqx32GwHRACxog7UdHtbCZfs7PNMIYcfyqVEBqkKW6pBiaCWsTipGVVs+XmuZ3woHjVJMrndY2Orx2lI4ZjwMqsg/P88yew0Mr4RhVT1/+1vQasm4MGXQ+v2etcxaDcMqYfhGzktkLPNbYHIdVIXL6pulENtXGY1ZUUp9emP7rLUvFFNGvwlWjDEJrfVXgOe11s/iT7u+EjgK+G6+m2UYMAu/BcQAaK2PAn4JTAFywPPAt40xK/P7Z+AHQeOBT+ePfa3btdu11g8A96/L01pfAxxijDm6IG8G8Jwx5hda6/H4ywmPNcZ0mcahtb4c+Eo+/V/57FpjjLvVL5AoifZ/fMjq0x+FrEfl6VOZH68i/cRCMiqA6wSwQEdtkOWjh7Gzu4wRiQ7SBAm6HvXxOCkCJKkg6HmkC8odm1rIoug41lSEeXHyEaSDYbCWoZksWUfx3qh60qFAfpVbD0KbX+XWtRaUYn7nZEFFPOmn4nEXEhlem6egPspTCwpXNfDT/5jrQUf+VzTsQSQA2M4YyQG8znMsl+7rcfNMf1/YgffPhkl1ihMf8XjqE0tFEB77vMMx47uuoPDbmR7fe9HDAj+cprj+sACuZzn5UY8nGy3RIDx6ssNnJnQ9b0ncctB9Lk1xmFALr54eYGR1+XxgC7EDu6Pb46FAGP/+QEUtud+v1lkxxrwO3ADcC9wD/AI4CTgZv3VlMHAn8LTWuj5/Whr4Fv6LswcwCvhtt6LPAW7BX6zmlu7X1VrX4M8Rf6WXnsev8s/hz8aY6vwmgUo/1Hbja5D1/0V33D+b5FP+wm2u4wcPCoh0uKwaVs/EFctxCXb+0VXRTgNLGc9CdknMZ2RqBRVukl0S89Ct77NkwhDeHTWcVCiCVYpYziUIrKiO+oEK+N+eLOtbUjZlU9+0KvINim4++OlJIN96A5ApDEt83c/63Tvr92U8+OXrlrdXwlOf+LnJHPxm5ob1vv4Nr/O8G9+0ZF3Le6vgyUY/N5WDm3s4757ZlqZ8IPZJK9z/YRGviRADlHVUl62kdbF2QuGG/7/2WuDWYsvoV8FK3i/x52ongBuBbwOXGWMajTGuMeYOYBlwPIAx5hVjzJvGmJwxZjnwK/zWmEIPGWNeMMZYY0xHPi+gtW7RWrcAzcARwDV9/eT6Ujwel3Qvp4Njazofq6oQXtTvaikMHjxHEUllyTp+Q6bfCuESo40AHpVkqLftHN78BievfI6943PwnBCJWIzd16xmUmuc4fFE5x9rTSrbNThxbcHY+q3kFhSwsQ82W3CdIj45YqGu4cuUer/rJ+ysv9aIaLYzve61Hbt+XDEjqyDVkWBYJYQLGo/GxjZ8Lwreio0eI2lJl1N6R2WtdfGDlcuLPaffdAOtY4xxtdaz8Lt0BuEPYp2utS78uA4BYwC01vviBzh7AZX43w27D3xd0MPPWkaKAAAgAElEQVSlXGNMXb6MEHAaMENrrY0xs3vvGW0/sVhM0r2crvz9Z1CRAO6KdmquOJCIF+bDc1/GWZ0mbf3xIoFwlinzmvi/naZw4MfzCFhFFkVhSJBUFbjWIZBvn3hlgsZiWROrIxMMUpHLkfRcPBSDUlkOaFrLm8NrccEfo5L1IKQ23npigY19ubJAR9YPUiqCXW+cuC4o8iwBPLygwgLV1QGiYRhdBdVhCDkQDcI7K6E1A1MHw1OnBvj8Y5Y5a+DIBvjR/g5KKR48KcAtb1km1MKvj4hs8No+cEKAH7zkkcrBLw91iMVixICHTnL47UzLuBq46QiHWKTre3HGrjC/BV5oshwzTnHazg5QHr8nkpZ0T+m+VGbrrPTkGDZskN2ofhesdLMaf8bO0caYNzdyzAPAQ8Bpxpg2rfUJbHjzpE2+YMaYLHCf1voW4LP4U5LjQFW3Q0dtQd2LfpNE+QoMrWLIPSd3Pq4Ahi/8r42fkLfqzjeJf+MRqsniEuDj+rGYqslMam2iLVTJh8MnsrYiQibo/4lmAwGGtbWxNBoiG44y37VMXLGYfZYvZFHNCBZX1TBx0Dx+dKjDLjtN6DJjqKmpicbGRiZOnLiJmUR9s4bLq2dsmHfyZIeTNzGBf2Kd4uGTNxyDc+IkhxMnbfp6Vx3ocNWBW1hJIUSfUkp1WVsFv+EgCnyz2DL6dbBijLFa698CN2mtzzXGzNVaVwMHA+8bY5YCNfg3T4rn1z65Ykuvo7Ved2+DwcC7+eyZwC/zLTfvAhcCE7ag2OXAAVprZ91UbLHjGHrOfrxx3Syi85aweMgY5k7049ymkSM5dN5MLnjlbv7xqaN5uO4YAAa1d3DCnGc5YfYPupVU+F9/bI/XamhokOnOQuxgrCqrUR5ndnvcDnxsrW0rtoCyejZb6SfAY8BjWus2YC5+4LDuuZ0PnIvfEvIw8Pciyw1orRNa6wTQAlwFnG+MeQ7AGDMD+DXwNP4YmeHAq1tQ79vxW2bW5MfGbH46hxhQps09m1ZqSIe7fmdYG6rHI8qX336Boz40DG9rY+/FsxmXeadENRVC9DflNMAW2M9a+1LBZqy1bUqpS4stQNliZhGIgULe7DKz4No3mP3zWTTtOox0OExlOskxs/+Pxw6YhueE+GDERNoqqvnqq/fwn1PauO6GG0pdZSFE7+mzKOLWfZ7u8nn/rbeOK1nEopRqs9bW9JC/1lo7qJgy+nU3kBD93fgfT6PjpflEXl1IRTDNmPblLLMjSQejvDluNwDCuRwrRlYTqy35tyMhRD9RDgNsCxaDCyiljqRrcDYRv8ejKBKsCFFiU589nUmNq/hk39+RDkcYM6iJlspDGR5P4DoO1ak0NhBg7Niex6QIIUSZWrcYXBR/DbR1LP64zUuKLUiCFSHKQGTiUHZpvgaANRfcjbcsQHVm/RokLdW1DNtOUx6FEANA6RtWyC8Ah1LqL8XeXXljBsIAWyEGlNoffJaqdKLzcWW6nbVTZrPPPvuUsFZCCLF1tjVQAWlZEaLsBHcaTmDUbUz+aGc8pVgz9R0IWpl+LIQoWjmMWVlHKVWDvwL84cAQCtp9rLVFfbBJsCJEGdrj1H149dX1M+Gvv/76EtZGCCG2ye/xV5X/Gf59/c4ELgP+UWwBEqwIUaYOPvhgTjzxxFJXQwjRD5XB2iqFjgV2tdauUUq51trHlFIGfzX5m4spQMasCFHG1k5v5IO972f14/NKXRUhhNhaDv5K8gAJpVQt/mKqm7jxRlfSsiJEGfnLn1eSTOUYMQIGX7KIBYuaAEXTyc/QVP8M+6wt+lYaQogdWDmNWcG/Jc3hwPPAy/jdQgng42ILkGBFiDKwuKmDH/+wiZqMiwJmMZGz8oGKT0GzJdOSJFxXUcKaCiHEFjuP9R9m3wF+CdQBRc8SkmBFiBLLZF1+9MMmBmfczjzPWjZcKEHxwb73ss/8c7dr/YQQ/U85taxYaxsL0ivx79e3RWTMihAl9tWzP6SuIFABcKztcU2nXGNq+1RKCNGvWaW6bKWkfOcppV5QSr2XzztMKfWlYsuQYEWIEgt5wQ3/EJUiFep+I25LD0cKIUS5+xnwDeCPwLp1VRYDPyy2APnkE6KEnv3XagZlchu2oijFu7tO6J4JuN2PFEKIDZRTywpwNnCCtfYB/PsCAXyCfzPDokiwIkQJ/fHuNRu9hceyYXUb5ClgoZIZQUKIfiWAP/sH1gcr1QV5myUDbLeR1loDVwIHAxH8O0n+E7jBGLOslHUT5c3zPNQmFm7auXHpBnkWxSASrNrtpwyd9ZO+rJ4Qoh8rg9aUQv8Efq2U+h74Y1iAn+MvClcUCVa2gdb6GPwX+7fAN40xS7TWI/FHOh8OPLCF5YWMMdnNHyn6o1kz27j34WbeWWNJudCQSPHxyMHElqwmaKHS9dYf7Lo9BiugaGI3Js+eiadOpfucoQ2aSh1AKYiEoL4K6qqhthL2Gg9Tx0JdFTz3DoSCcPhuMH44HLJr1zLeXwiL18ARu0FFBGZ8AI6Cw3brhVdFCLEDuBT4M/7CcCH8FpVn2YKpy8pau/mjRI+01nOBl40x52xk/38BPwImAO3A48Clxpj2/P4FwJ3AkcB+wLnGmC0KcLaQvNkl8tCfljLjmRaC1mIBD/+bj7IWz1GEPEtbOEhlJtf5DWK/t+ey6yc9BSxQRQs7Y/qmsj84GW48y0/f+xJ87X/A82D/nWDP8fCnf/n7vnsC3Nzjr74Qojh91vxx46Evdfm8v+zlw7d7U4tSaoS1dnnB42HAOGBRYX4xZMzKVtJaT8FfKvi+TRzWCpyBv/jNofntym7HnIcfdcaAx3q/pqIcvP5CM4H8FwMFeAqC1hIAQp6fX9NtoO2iUYM700NYxC68xnjexyFHlkjfVfbO59en737RD1QAXp8Ld79QcNwLCCHEJnRfofY2a+2bWxqogAQr22Jo/ueSjR1gjHnKGDPLGOMZY+bhLzF8VLfD/mSMedsYY40xyb6qLEA8Hpd0idLDR0dxC/qQnY20cRVOVlb54KaKtTTwEZUkGMQKRjKfETT2XEAvyO08qjOd2WlEZ9rWVMDOo9cfOHUMUPrXVtKS7q/pvmQd1WUrke4XPmKrC5JuoK2Tb1n5CDjGGPPcRo45Brga2AV/8G0AWGmMmZDfvwC42hjzl+1SaekGKpm25ix3/HoRby70SIQCjGjtIGr9v+SNfYzsOauRvT9qoppmpvBWZ/4ahlNJnCgdG5xT1EeSwh97MmYwhBxYsBKUAxOHw6FT4arTYHh+JlI6C9c+BE2r4aLPwOhB8IuHIOD4x42o38JXQghRoM+iiF8d/u8un/eXv3RYKbqB2qy1NQWP11prB21NWTLAdisZYz7WWs8DTgc2CFa01mHgUeBy4E5jTFJr/S3gB90O9bqfKwaemvoQ3/t51yUFZs5s5c5fLia0kXMi2RygSFBHK4OpZQ0eDi0MQZFk7V3nMfrsz/ZtxSMh+NnpXfNuu7BvrymE2GZlMhsoqJQ6kvVBWffHWGuL6k+WYGXbXAxM11qvAG41xizVWg8HzgEW4bemNOcDlanAt0pYV1Fm9t23lpsjy6nP5Aj00OYVa0ngN4Y5NLIHUzC0MJgUFQyyd2/n2goh+pMyCVZW4k8iWWdNt8eWIheGkzEr28AY8y/gEGAq8L7WOg68AgzDb225CPiV1joB/I5ND8YVO6CRw10+HhTboH8upWBIWwegCJKmjpWsYjQrmET7Pw8uRVWFEGKLWGvHW2snbGIregVbGbOyY5E3u8x4ruXMs+YxNJnp0nltgTMefqmHLiJL24u7ccQRR2yvKgoh+k6fNX9c9+lXu3ze/+iFg8uiqWVrScuKECXkBBThZKbHfT330XYwcWLRX0aEEGJAkGBFiBK75tfjNshrD27kTzNSRUNDQ8/7hBAir8xuZLjNJFgRosTGj6smXgNZ/Klh8VCAVDDAhr12ltF/PHz7V1AIIUpMghUhysCdd+3Gp88aThxQWZdP7boEb4PubMXwr8n9eIQQmzfQWlZk6rIQZeILJw3hCycNAWD69EaWPz6W0acsAtffv4+9uIS1E0KI0pFgRYgytk9OAhQhxJYbCK0phaQbSAghhBBlTVpWhCgzz9T/mURVlPrJa+HEUtdGCNEf2YHVsCItK0KUk7smPQrKoWF1G+mP6jGfeajUVRJCiJKTlhUhysigjhRDm/1byI9dvpZPvHp0ieskhOh/BtqYFQlWhCgjI1e2dHlc05EqUU2EEP3ZQAtWpBtIiDLx8EWvoazXJS+WSJaoNkIIUT4kWBGiTMx/I86a2urOxxYIlK46Qoh+zFOqy9bfSbAiRJnoiIapTnW9qWH//4gRQohtNyDHrGitxwCLgAnGmAUlro4QRYl4HulQkMp8wJILOFjX28xZQgixITvAvuqURbCitZ4BHIh/LzeA5cCtxpjflKxSfUBr/X3gK8AkIAW8BPzAGNNU0oqJklr81kq+etNqDguHeOrg3Tn2tdmEci5mj0lMM3PgM1fDsx+sP6H9XqisKF2FhRBiOyuLYCXv58aYXwBorQ8AntdazzLG/Ku3L6S1Dhljsps/steFgUuAmUAIuAV4AtizBHUR20l2eQfNf5/Hoqtfx23JkoyESEdCuNayfMRgKlIZLm9NcMl5n+P4xpX889P7AjBx4TIqs+mugQpA1Ve2riLh/AiYCcPgjMNhl9HwxQPBkd5gIQaagTYbqJyClU7GmNe01rOBPYB/aa0HA78CjgWiwIvAJcaYFQBa6xHAH4HDgRX5Yztpre/GDw6ywEnA34CLtNYXAd8FRgBzgMuMMS8XnLfR/Vrra4BDAQOcgz/+51rgH8BdwH7Ax8CZxpg5+ed1XUG1UlrrG4A5WutBxpi12/aqiXKUa0nz0f4PkWpK4OD/wcXSWcKe5fGj9iVZGQUglMmyy/IWVMEHTC4YJNCbTbmZ/B0RP1oGP3nAT593DPzxot67hhBC9IGy+0qltVZa64OBXYD/aK0V8Cj+5IjdgXFAHLiv4LR78e9N2wAcBpzdQ9GnAU8BQ4Hva61PB34OfA0YDPwJeFprPS5fj03uzzsMmIsfzJwJ3AjcAXwTGIQf4Nyyiad7FLBYApWBK/nuajL5QKXQqsE1nYEKQDYcYvmQWqLJdGfemOVrsH39Jzr9zb4tXwhRElapLlt/V07Byo+11i1AO/AKfgDyBrBvfvumMabVGNMBXA58Wms9Rms9Gvg0/tiPVmPMcuCnPZT/ijHmb8YYN1/G14E/GGNeN8bkjDF3AO8BZ+SP39x+gI+NMbfny3wKWAM8Y4yZk+9mug96XoBUa30QcD1w4da+YFsqHo9Lejunc2NDBOojWLqqjXegvK6DZ9dWRnivvoL93pnLUS+/y+SFK/Cc7mf2sgN33qDOkpa0pLdPWhSvnLqBri0YszIG/x/9nfhjOiLACq27/N9P4bek5Nu2WViw75Meyl/Q7fFY4MFuefPz+cXsB1jWbX9Ht7wOINa9IlrrQ4HHgPONMU/2UNc+EYvFJL2d0/UThxF95RRW/O49Vv1hDsq1dERDeBYOfe0D3tp9Em4wQALLJ4OqaY2MpUYFGZRIskfjUvb9YBa9LlYBn9kb9psM3/pcrz5fSUta0sWn+9JAaE0pVE7BSidjzGKt9YPAdcDv8FtbBhljNpjHmQ9swO8emp9Pj++h2O7nLurhuInA9CL3bxWt9Wfwx8ycY4x5eFvKEv1DxdRBjP/dEYz/3REb7DsVeH7P+7lp6p6c9tqHjLQKx/MI5Vzmjx3O+KYV0NrtpOP2gFsvhEkjt0f1hRD90EC763JZBiv5AbOnAe/iD2B9F7hFa/0TY8warfVQ4ChjzAP5wGYG8Cut9deBCuDqIi5zN/BbrfXjwFvAV4G9gdOL3L81z+sL+INvT9+eLSqivB313ukcBdy811MsnDQW6zhkImHGLFuN41mwEtMKIXZs5TRm5SqtdUJrncAPTlYAZ+RbU07GX8xzptY6DrwGHFFw7hn4XUWLgJeBv2zuYsaY+/DHttyDP9bkIuBzxpiFxezfSjcBlcDf1j3X/NawDWWKASKHgoKm23Q4RH28o4Q1EkL0VwNtuX1lbR8P4BPlRN7sMvbjg14iWBmltbYaZS0HzfyIcU0rmGYvLnXVhBB9o8+iiCtOeqfL5/31j+/dryOWsuwGEmJHtNPuUWqmf0JF1iWazlCbSG4w0EoIIYohA2yFEH3i7D/uz5tqptxpWQghupFgRYgy0n0QmfTbCSG2xkBrWSmnAbZC7PDi0VBngGKB3PBS1kYIIcqDBCtClJFD286hLRIkEQ7SWgkHLpfBtUKILTfQZgNJN5AQZSQQCnBk6nymT9+mtQeFEGJAkWBFCCGEGGBkBVshxHbz+u0f8+g9q8iFAlx5/97UDolu/iQhhBhgZMyKEGVq3pVZnr5rKW01laQjYa4+831y6VypqyWE6AcsqsvW30mwIkQ5Srq0VdVjoyGmNi5l9w8XMnbJaq459KVS10wI0Q8MtAG2EqwIUWa8jMuQLy9mcDJFRSINgA04DGrvIBEKYV5YXeIaCiHE9iXBihBl5uOvPkkEl1ELWklVVdI0aQyNO48jUVPFmDWt/P43S0pdRSFEmbNKddn6OwlWhCgTzW0Znvjei6x6cBHN1KCsoiNW4e9UipZBNeyzaDn1HanSVlQIIbYzmQ0kRBm49vhHGDWvBdVSTXvNYIa0JYmksjg5Fy/o3y0oksrw/i4TqEx0lLi2QohyNxBaUwpJsJKntW4AZgNTjDFLe7HcQ4CXjTED6zdH9Ip0e5qbD7uXQ5cuY47alUNWNlJBimZqeHr0TjTMW0rr0FpCmRzt0RCr62O8XFfLj1Mu0ajc8lAIsWMoaTeQ1nqG1vrKElz3bK31vMI8Y0yTMaZ6XaDS0zFC9JZMOsuFxz3FA5/6G389+GiO/ualRCo7cGqS1Ks2JrGIxnHVDF/TxpSPFjFu4Qqq2jO0V1byqY4kX/q8KfVTEEKUMU913fo7aVkRogfuR6vI3Pc2gUmDCX9tX1jZAn94Frc1TfzhxTgLlxLyEigFITqwFrIVNaSyNeRyECQHBAjTjgO4KBQuDlmenbw7HZEQ569ZyN37HcnshlFgLd/7yom0VFZyyPxGfvfnxznl9QUEPEtVNs2KYTUkK0KkQkFGrE2w24pWfr/bP1k1vI5kIEA8lWGvFatJVleSjkSoak1Q0ZGmJpEhHQmQDAcJeS6uowhbSyoSpqW+mlo3Q7Q1iR1cwfBDhrPr58ewYLFLIKiYdsIwQhEZ1iaEKL2yDFa01uOAW4CDgSTwD+BHxphkfr8Fvgl8HdgFmAWcbYz5ML8/BvwOOAGIA1cBdwJHA2ngNiCstU7kL3kCsAD4BBib33o6BuA5Y0zn66a1vgY4xBhzdP7xTsCfgH2BRuCubs8tCFwOnA0My9f9O8YY+apcJrxVCRIH/x67xh8b4i2LE/3LIzB7EQEgSowICVxCBG2m87yOZJAUMSK04VEFQJIo1awlSpY0QZ7efWce2mNf7r3/fwC4fOhIaM9C0KGlshKA90eMoik4AoXCcxRrqqtYNbiaukSCfWbNY/f3l+FYi+somisrqA8rJqxtxQYcIskUzYPriNdWc+jzswjlPCywfEQljvLv5JwNKsLpLMOWN7NszFCGeWlCSxIsfTDBwscXsmL0cLKRMAtnJTjj6snb86UXQvSSgTZmpey+NuX/mT8JLAfGAQfgBy03dTv0bOALwBBgEfA/Bft+C0zED2T2AI4HAgDGmP8AFwKN+W6famPMjMKCizlmE3V/Aj8AGQZ8MV9OoZ8CJwPHAYPxg6intdb1myt/W8XjcUkXkfY+XNUZqACkn5sDsxd1Pg7RgcLSXZgkAJZQZ54CskRQQJg4z07Zi/0Wze/cP3PIePAAb315Nn9eYSE24KAApWDNED+oCXgWlXYJZrNdrhfKZPGCAZKVkc68SNrtTDsFVY8m0yQrIwQ8CwqUhXDaD8CaZiVK/l5IWtIDOS2KV3bBCjAN2Am41BjTboxZAlwJnKO1LvwMvzE/ziQN3A1oAK11APgKcLUxZqUxpg347+1U9/2B8cBlxpikMeb/t3fn8XVUZQPHfydbkzTpvpeulAKFAtaHfRWFFwRUqMoOtYCCoCiyvSBQNtlUXlERBErZRWRH1ipFqAI+UEqhQOm+70mbZs+95/3jTMJtSNqkTXKXPN/P535y7syZmWfm3tz73HPOzHwO/KZ+ZhT/T6P581U1pqr3ASsICVW7Ki4utnILylljB+CGdG+Ynv/dr8B+oxue11BEPPrXSUxZqqPWFKhrmO7x5FFJHEcthRw272Oe2X1varKzieOozIkSmzpPfmUVu61cwmVvPs2Ympk4HyOW7djYPY9E9ZfOrstyLBnci8rCgobt1WVnU1WQT05NLQUV1Q0x1uR9EW99/7UHKgu7UFheRSwrSr+ys6jOD0nO6H26J/21sLKVM7ncnuK4zR7pLhW7gYYAa1S1PGHaPCAf6AusjqatSJhfDtS/A/oAecCihPmJ5fa0A7BaVRPPLV2QUO4DFAHPR11Z9XKjZU0KyOpRQPE7F1D7zMdk7dib3CNHw6l7wmNvEa/z1P51PrUzPie3vITa/O7k1FZAPE5e71x8ZRWxjZ5sX44DsqmgljziZFNHDkfPnIernsYd+32L9UX59KitZE1WDtk+zj3P/Zm+1ZvoubiYBXU7kx2D0v45OO/JqamjLjebnNoYMed5d9cdWNm7G4PLy6mJeZZ07crodespKyqi15oS8iqrmD+0O702VlGb56jukgt4nPPk52WxMTuPjb2LGJxXS1ZxNrk79WLkgf0YfdQgFi+uJTvHMfbQXsl+KYwxBkjNZGUJ0FdEChO+9EcCVcCaFiy/FqghdCHVt7cPbVQn3oL1NFWnDMgWkS5Riw7AoIT5y4B+jWIf3ii2cuAbqvrfFsRgkiRrYDe6nLf/FxOKCuCcI8gCup3X9DK5QEEL1v19IF5Txxkn/ouD5s7l80H9Oe7z91jVsycDllVQUAWl5OE89FpVxYphPVjbtxfV+blUVtSwfqcR5OdX8cfHZft3tAl9dmmX1RpjOlCmjVlJhWQlR0QS73v/ITAX+I2I/ALoAVwP3K+qXx4o0IiqxkTkUWCSiMwiJDk3Nqq2kpBUdIu6iZrSVJ05wCbgbBH5E3AAYVzK+9H8twmtOLeIyKWEROaihNi8iPwO+LWInK2qn4tIEWFMzqy2vL6LSW1ZeTk8/PThAEw+4G4qKrI5cc479K0sZyM9KaGYKvKI52SxdHg/agry8MBnwwYwbu4iJr399eTugDEmpWXC6cqJUmHMyjWEM37qH2XA2YRukcXAu8A7wMWtWOeF0bJzgI+A1whd9PWtIa9H0xaISKmIHNrEOr5UR1XLCGcg/QLYEG3ngfoFVLUO+BawB6G76ingz03s77PAsyKyEficMAg3FV4LkwQT//0j9utTzaL8AczqswNvjhzBjNG9mHbIzrx4zF7UFIQxKzmxGPstXMoLY3ZMcsTGGNOxnPdbbaxIeyKyM/ApMLiTt15k/oud5jYuKWX20MlU0Z37v3cQG4sK6RqdnTN83Xq6b9jIWwP78exTY5McqTGmDbRb+8fZp3y+2ef9vY/ulNZtLanQDdTmRGQkMIDQItMHuB34VydPVEwa6DakB8PuOIzPL/wvvUrLyPVxdly9Fu8glpVF/sZyinrXJTtMY4zpUJna9ZBP6H7ZAMwCKoBTkhqRMS008CfjyKWGUYuWstPK1eTE4+TG4uRX1zC3Vw9+8bPByQ7RGJPivHObPdJdRrasqOpsYPdkx2HMtlr77HC6n1tOZZ84Piu6Ropz9KqrZNw3+iU5OmOM6ViZ2rJiTNqrHRWja0k5xD3ee5Z3LeTS1w5PdljGmDSQaTcytGTFmBTV5+JunPL6NyjPz6YmB254fC8KinK3vqAxxmSYjOwGMiZTdO+fz6R/HJzsMIwxacZnwCX2E1nLijHGGGNSmiUrxqSgeBxmX5LNnwc9ze/2eDHZ4Rhj0kzcuc0e6c66gYxJQTMvz+Oj3frjcrL5tG8vysf+nStmtfuNuY0xGSITEpRE1rJiTArKy6+jR202w1ZXMnb1Jl6SMckOyRhjksZaVoxJMavXVlJQ6zjtxXfIicWpyM/lya/tAYxIdmjGmDSRCacrJ7KWFWNSzPu//4QdVm8gJxYHoLCqlrHzVrJmzoYkR2aMMclhLSvGpJj4olIquhWwrirGg/+zN+uLCxm5ah0f/3gWf5x6ULLDM8akgXiGnbpsyYoxKeaVT2o52Ndwy/iDmDG4L11iMcry8zhk9pxkh2aMMUlh3UARETlYRErbYb2nicjCtl6vyUyzznuKE+bOpW/pWqYP609FbjYl+XnM7l1ETVHXZIdnjEkTmXYjw7RJVkRkmoj8si2WE5FJIjI1cZqqvqmqPbZUx5g2EYtRN/H/iPU4jZqvXEzttU/wfpdLWZJzKQV/ns3I9aWU5edBwgdMeZdsnPfc/NP3khi4McYkh3UDGdNWvIc/vARvfAz/nQtL1lCRlcNk+RqvjN6Lr837iJ//+yUgi2wc5fQg/oGHD/7DWErJpZpSaimjD3ssX0WP6ipKc7tAbQyyYcT8FdQtctw55jlcLM66wnz+vfNwhlfX0quqirx4jKzeBSz/6kD2ObIPE8amzW8RY0wby7SzgdI+WRGRk4D/JZzXWQ48B1ykquUi8gfgYGB/EbkcWAZcDVwBZInIpmg1ewBDgamqmiMiJzZT5xDgl6o6KmH7U4A6VT07er4PcCewC/AB8GqjeAuB64DxQHfgXeACVZ3bdkfFJMXdr8JP791s0uujxvKTb50FwPhZ7+LIpr5BsysbKaMb4KimiFyq6UI55fTE45j80FN895TxxD1QB/fJrlzx+ntU5WYRz3IM2mpXclYAACAASURBVLCJb834lOe+OoaB5eUAxNdW0usfS7h2TS7dJ3bn+NGWsBhj0l8mfJJtAE4BehASk4OBXwKo6gXAm8D1qlqkqjur6uPAr4Bp0bQiVZ2fuMKW1GmKiHQHXgL+BvQCfg78uFG1ewiJzH7AAOAd4AURaffb6ZaVlVm5PcsfLaax+T37NZQPWDwHNhuh76MHOOLEyaKEwTggC88ey1bg476h9uKexdQ/c4DzkB2PE4/FGuqE6Z6+5VXMWuOTcxysbGUrt6jcnjLtcvtpn6yo6kuq+rGqxqPWiTuBrycpnGMJrTu3qGqNqv4XuK9+poj0ISRWP1bVVapaA1wLDAT2be/giouLrdye5RMPhC55JBr/8bsMKV0LwMs77wnEG+ZVUkgl+VTQhXw2UUMeiclMga/lG598kQCNW7aGxX2647McsazQurKmqJC8nJyGJCaOoyY7ixUDijkhalVJmeNjZStbebOyablM6AY6gtC1swvQBcgGVicpnB2ARarqE6YtSCjXX4L0QxFJXC4XGNLOsZn2dvAY+Oh2mLUYFq+Bv04nPr+UV++exOoevdh1zTLixHF4KingM3Ynizj9WUUJvckiThZ1xMkBPOtyivj6ulKKl+Tjgc/79eajWIz+JRtYUdCFDV0LyM7OZkxpKdmF2Qwalk/fr/Skave+nD86j6Hd0v/XlDFm29h1VlKIiOQBzwCXApNVtVJELgAuTqgWb2LRpqa1pE4Z0Pj80UFA/c/fZcAwEXEJCcvwhLqLor87qeqaFsRg0s2ogeEBcOGx7BBN3qVRtULgKwnPy/7xKbOPf4x+ZeBzPCV1PXl3l11YNbAXw6prABg6dxE3PT2OgqJ27zE0xqS5WGblKmnXDZQjIvn1DyCP0JpSEiUqY4ALGi2zEhjVxLShUbLTnKbqfAD0E5FjRSRLRI4nDLqt9wJQBFwiIrkiMg44q36mqq4GHgXuFJHBACLSQ0SOF5GiFh4Dk4GKv74L+268lhH+Wj7rMYAKCqnNzd6sTnVuriUqxphOKd2SlWuAyoRHGWHMx63RWTt/JCQDiW4HRERKReTjaNoTwBJgZTS9qTvEfamOqs4DLgT+DKwHjgKerF9AVUuBY4ATgRLgDuBPjdZ7DvAZME1EyoBZwPcAjzHA0jE7EAd2+nwFBRXVAORXVtGvxO4NZIxpmUwbYOu8t+/ITsRe7DTw7KT36fKrD/Fdsljfs5A1/brxzJ47cnD5aq7/y/7JDs8Y03baLYs49uylm33ev3DvDmmdsaT1mBVjMlHXteUs6VNEcUUthaU1PH/wcD7u34tXrxme7NCMMWnCLgpnjGlXB960DxMWz+avh4xtmNZv9QbyumRvYSljjMlc6TZmxZiMV1DchZ1KNpJTG13szXsOnLc8uUEZY9JKHLfZI91Zy4oxKajvmvVc8eJ/eHv4IHZZuY7xJ/ZKdkjGGJM0lqwYk4JG3pZD12c2MHBeLcfcvhdDvtI32SEZY9JILAPOAEpkyYoxKar/d7I47rgjkh2GMcYknSUrxhhjTIaxs4GMMe3u448/prS0lOnTp9OzZ08uu+yyZIdkjEkjsQwYVJvIzgYyJsVMnjyZ0tLShuclJSXccsstSYzIGGOSy1pWjEkxc+bM+dK0kpKSJERijElXdiNDY0xS3HjjjckOwRhjksJaVoxJE2VlZckOwRiTJjLh5oWJrGXFGGOMMSnNkhVjUsiVV165xflXXXVVB0VijElnMec2e6S7Tp2siMgmEdk/Kh8mInXJjsl0brFYbIvza2trt5rQGGNMpmn3MSsiIsAvgQOBLsBK4EXgFlVd0d7b3xJVLdpaHRE5EHgLmKKqP2j/qExndfnll7eoXiwWY/LkyUycOLGdIzLGpKtM++XdrsmKiBwBPA/8DjhfVZeJyEDgbOBQ4C/tuf028iNgPfB9EfmZqm5orqKI5KpqbceFZlLF4sWLmT9/PlVVVcyePZvVq1e36/bmzJmzxeSmZ8+eFBUV0a1bNw499FCGDh26WZwjR45smGaMMamuvVtW7gQeVdWGy29GrSnXA4hIIXATcAJQQGjB+KmqLo7mTwOmquoN9cuLiAcOVtW3RGQScDDwDiEBAviTql6TUH8P4Fbgq0A28L6qfqPxupoKXkR6At8DzgLuAE4H/pAwfxrwATAcOBz4FXCziJwDXAgMAeYDl6nqq9Eye0br2i2K523gAlWd14LjaVLQ4sWLueuuu4jH48kOpUFJSUnDtVlmz57NeeedB9AQZ1ZWFueee64lLMZkqEwYp5Ko3casiMhoYBTw6Baq3Q7sFz2GAWuB50UkuxWbOgRYDAwCvgVcEXXdELXivBE9hgMDgJtbse4zgE3A34BHgB82UWciIfnoDtwRJSqXAacCPYErgadEZFRU3wOTgMFRTJuAh1sR0zZLPPXVym1Xnj9/fkolKo1575k/f/5mccbjcT755JOGOsk+hla2cmcsm5Zrz5aV+nvaL2tqpohkAWcCx6nqsmjazwhdLvsA/2nhduao6l1R+W0R+QAQYDqhJWSuqt6UUH9qK/bhh8AjqlojIvcBPxWR/VU1Mba/qeo/o3KFiFwIXKeqM6NpL4rI68BJwA2q+mHCstUici0wS0QKVbWiFbG1WnFxsZXboTxy5EiysrJSNmFxzjFy5EiAhjizsrLYddddG+ok+xha2cqdsdye6jKrYaVdk5U10d/BwCdNzO9LGHC7oH6Cqm4SkdWE7pOWJiuNB+mWA/XvhuHAl69d3gIicjAwBjg5iu1DEVHCGJbE2BY2WnQE8EcRuSNhWg6wNFrvjsBtwL5RnD6q0xdYtC2xmuQaOnQo5557boeOWdma5sas1MdpY1aMyWx1GXYjw3ZLVlR1jojMJXzZN9WasQaoJiQUcwFEpAjoByyJ6pQBXesXEJFBrQxjIfDdVi5Tr77L59VwQhMQkovdooG29Xeaa/xzehFwjao+0cx67wKWA3uo6joR2R2YBRn2zupkhg4d2vDlf9RRR221/uOPP86MGTO2a5vFxcWtPo05MU5jjEkX7T3A9seEMSirgD+o6nIR6U8Y57EAeBC4XkRmA6XAb4BPgXej5d8DThSR3wJVQGtvjvIwcKWIXAb8nnA21yGqusWuIBHpRUhyzgeeSpjVBZhB6F76fTOL3w5MEpHPgZlAPmFw71pV/RToBnwOlIpIH+C6Vu6TyQAnnngiJ5544mbTrrvuOioqWtYTePPNrRl6ZYzpbGoz7Odvu14UTlVfAw4idKfMEpEywhk//YBpwM8BBf5LGCQ7EPiWqtZfGet2QhfSPMJZN39v5faXA4cBRxC6YVYCl7Rg0TOBEuBeVV2Z8FhEaBn50Ra2eQ/h7KP7o3UsBq4CcqMqPyecwbQReBN4oTX7ZDLX1Vdf3aJ6lqgYYzob573fei2TKezFTgNbun6KJSrGZJR2a/8Y9tO1m33eL7qjT1q3tXTqy+0bY4wxJvW1++X2jTHGGNOxMu1S6tayYkyasC4gY0xnZcmKMSmmX79+yQ7BGJPmKpzb7JHuLFkxJsVcdNFFFBQUbDbNWlWMMZ2ZjVkxJgWNGzcOgOOOOy7JkRhj0lFl+jembMaSFWOMMSbD1GTYRdGtG8iYFPPhnI088tBIHntkFEed8lmywzHGmKSzZMWYFDPpmmWMKqtk1IZydttUwf4T5yU7JGNMunGNHmnOkhVjUkz/mjpqs7JY1rWA7LinWyZ80hhjzHawMSvGpJi4h7t2G8nGvFy61tYha0uSHZIxJt1kwOnKiaxlxZgU8++BfckGBlVWU5mTzaLCwmSHZIwxSWXJijEpJj8ep388Rk1hHjtVVlFcXsn07BuTHZYxxiSNdQO1MxG5F8hR1QnJjsWkh5ouuXzauxu7L1jNd9/6hO5VVeTRNdlhGWNM0qRNsiIi04D9CfdnigHzgRtU9cntWOcUoE5Vz26LGI3ZXnV1MSpysuhaWcN1D71BYU0dADV0SXJkxpi0YmNWkup6VS0CegOPAY+LyOgkx2RMm7n89P8wcMMm+m4ob0hUIAy63aB2CrMxpnNKm5aVRKpaJyJ3ArcAY0Xk68DPgAHAJ8AlqvomgIh8Bfg9MJbQIvMpcAxwDnBqVOekaNXdVTUmIicAVwCjgCrgPlW9Mqo7HrgaGA4sBCap6tP1sYnIROBKoC/wLOEM97qE+UOB3wIHAR54HviFqpa13REyKeu8u+CuVwGoc9l4wDvHvwYfwPLigYzNjjFj76F0r/Pceuoh/PDZd+lRVkkXV8vNlyxg9uBahqxfx9UvP8wityt58S9W7QFwZHXPZeRTx1B0+JAk7KAxJiVkVsNK2rWsACAiecD5hC6hMcD1wBmEFpd7gJdFZFhU/Y/Aq0AvoD9wEVCjqrcCjwAPqGpR9IiJyNHAA8AkoA8wGngp2u4B0TKXR9u6AnhMRPaN5h8cbe/caHuvAScmxJ0P/BOYDYyIYt8B+F3bHiGTkmrrGhIVgBwfI9fHWFo8mE/67sqG/B68NXI33u7Xk5m9i3ljaF8mnXIwK3vn091vYEGPQazq1hMdPoqXxwpD46Glpf6aT1mAw+M31DL/uOfxcZ+U3TTGmLaWbsnKlSJSCiwFvg2MBw4G7lbVd1S1TlXvAz4ETomWqQGGAkNUtVZV31bV8i1s4yfAXar6QrS+jar6VjRvAvCkqr4Uzfs78DQwMZp/BvA3VX0tmv8g8G7Cuo8FnKperaqVqloCXAWcKiLZ23dotq6srMzKySyvL6Up1dlfjEdZWtSVitzwVohlOZZ3K+TjkT3Y6LpSk/NFQ+jGgq7kUEtz6YiviOHr4h2/j1a2spVbXG5fmXUJ23TrBrpRVW9InCAitwJ/bVRvHlDfBv4DQkLwlojUAg8D16pqHU0bTkhAmjIEeK+JbY2LyjsA2mj+goTyCGBolHAl8oQurGXNbLdNFBcXWzmZ5f59YMf+MG8Vni8+PkaVzufD8t1Y3bUfY5cv5+URAxsGx1XhOWHeDPJdDvlUAd0Zsm4dp733CouyxpAVp2Fd9YmLBwbetB9Zedmps+9WtrKVv1RuV+mfn2wm3ZKVpiwhJBiJRhLGgqCqC4haPkRkLKFLaAEwGYjzZQuBnVq5rSVReVkT84cDc6PyImCOqu7WzPpNppv7J3h/Hm76J/jlJayikLll3RnTN4+u939Ev3Vl7Lvzjiwp6MIuqxZz26vPsPu6VSzP6s+5T/6NpX0HMbRyPct22I1eZ+xLTlEBebv3JsdBdo98yHbkj+pBTs/8ZO+pMca0mUxIVqYAvxOR54D3gdOBvYCTAUTkTOA1VV0OlBIGu8aiZVcC+4lIlqrWJy5/BP4iIq8TxpwUAntEXUEPAFNF5CFgKnAkcAJwWLTsQ4TxMlOAN4CTgH35Ill5AbhRRK4gDPrdBAwC9kkcpGsy3LgdYdyOOEJz2oBo8thrDuGzWevI+lM1P58xg59O+1vDIl3ilRzib0tGtMaYdJRhLSvpNmblS1T1UeBaQvfOOuA84JuquiiqcjjwnoiUA/8BHiUkFQD3Al2BdSJSKiLZ0TiUs4BfAeuBz4D/ibY1HTgT+DVQAtwKnKaqb0fz3yCMebk3WvYo4PGEWCuieMYQzkraAPyDkFwZw85je7MwJ5e1XXIpKSgCQrdOVkN+bYwxnY/z3s4Y6ETsxU4Du5+7nN4eelVVsOeC2czq04ern36ZPf11yQ7NGNO22q39w126cbPPe39rt7Rua8mEbiBjMkp2l1ze71tEeV5f/jukH/GN5ewRvzbZYRljTNJYsmJMilnWo5BN+bkN5a4uC5dhl842xrSzDPvISPsxK8ZkmvLczf8tu9XUJCkSY4xJDZasGJNiBq/ZiKuLg/dkVdc1XNzNGGNazi4KZ4xpR4O71lK7qpTq7Bw8nofOKUx2SMYYk1SWrBiTYt741Q48//zzrCnPYeJJRyc7HGNMOkr/xpTNWLJiTIrq27W5O0IYY8xWZFiyYmNWjDHGGJPSrGXFmBRz3kF/Z/6QHdlYkM+DU97jiSe/muyQjDFpJ7OaVqxlxZgUs2iHkcSKu9MzO48lAwYz4X/+leyQjDEmqSxZMSbFlHUvJi+6DUavmjoqi3okOSJjTNrJrDOXLVkxJtUUxL64pYcH1hUVJC8YY4xJAZasGJNiutTFiAFxIIYjO2YXhTPGtJJzmz/SnA2wNSbF7LRsBbsvWsaA0jJ01FCyaqqAnZMdljHGJI0lK8akmL3nLEQWLwNg1Jp1vDRmWJIjMsaY5NpqsiIi04D9gVogBswHblDVJ9s3tJYTkcOAqaqaNsmXiEwB6lT17GTHYlLLoJKyhrIDCmqzkxeMMcakgJaOWbleVYuA3sBjwOMiMjqxgojktnVwLZGs7RrTXmYNGkB5dg7l5LGoqAdvDx2U7JCMMekmw84GalVLhKrWicidwC3AWBGZDfwAuBboCxSLyB7A/wFfAUqAycBNqhoTkeHAAuAc4FKgPzANOEdVVwOISCFwHTAe6A68C1ygqnOj+dOAD4DhwOHAzcBVQLaIbIpCPR/4JrBSVS+sj19EJgJXADupqheRQ4EbgN0I4xlfUNUJUd1DgVuBXYAVwO2qenc07zAateSIyCTgIFX9RvTcR3H8IFrHx8AEVf1URC4FTo3qnRStoruqxlr8YpiMcsoTVTyt1WTF6tjp8LH0X7OJwes3Ubgpzp4LVvOzr73GXUccQHVel1av2xHOKsp2cN5e8Puvp00DpDHGAK08G0hE8ghfwLVATyCbkBR8BegvIt2B14DXgQHAMcBE4KJGqzoDOAQYQkgSHk6Ydw/hy32/aB3vAC80akGZCNxBSGb+DzgaiKlqUfR4ALgbOE1EEj/dzwbujRKVPYBXgPuAgVEsU6L9HAG8DPyJ0Jo0AbhJRL7XmuMVLTce6AMsAX4PoKq3Ao8ADyTEbIlKJ/bqO5VU52TTIy+bJX1602NTFR8N7M3G/DwGlJTz/Tfm0H9D6Tatu/5E6JiHP8yAfy/zW6xvjMkEmdW00tJk5UoRKQWWAt8mfAHPjeZdpqobVLWCkJzUEMa0VKvqJ4RWmMbjMq5V1ZWquhG4BDhCRAaJSB/gFODHqrpKVWsIrTYDgX0Tlv+bqv5TVX203aa8DqwDjgcQkV0BIUpIgHOB51V1ShRrpapOi+adDLwfzatT1bcJyU9rx5fcpqqLVbU62q60cvk2VVZWZuVULfuQVHg86wvzOfWsY/jR6UdyylnHMG3nwYD7IuvYTvWXcUmZfbeylTtpuV1lVq7S4m6gG1X1hsQJUVdInNBiUG8IsEhVEz9W50XTEy1sorwDX3wcfyiy2fd6bqN1JC7fpKj15B5CgvGX6O8LqroyqjIcmNHM4kMI3VWJ5hEStdZYkVAuB4pbuXybKi4utnKKlg/6ahWvfFjN6jrPXp8v5YM+fQEo6ZrP3L49eG7/Eazu0Z3t4YAf7A4H7+A6bL+sbGUrN182Lbe9nde+UWKyBBgmIi5h+kg2T2ggJArzEsoQWm3qovJOqrpmC9ttfJWs5q6aNQW4LhoMfDpwZsK8hcBOzSy3hNC9lShxP8oIY2S6RK0mAK0dBWlX+jINnjklH07JB+DIUzZ/61d1y+XaJ47gxhxHdvaXzwzy3uMy4KJPxpg2lGEfCW090u7vhDEkV4jIbcAI4DJCF0qiq0TkI6CS0E00VVWXA4jIo8CdIvIzVV0mIj2ArwGvqeommraSkDyMUNWGFhFVXSMizxJaVioJY1Tq3Q28IyKnA38ldIntG3UFPRbFeAbwKDAO+BFwXrTsHGATcLaI/Ak4APgu8H4rjtVKYD8RyVJVS1xMg/3nLmXvTxfxr5FDGLN6HVVdHV26NP+vaomKMSbTtenl9lV1A3Ak8A1gFSE5eBD4baOqDwNvEloq8gitHvXOAT4DpolIGTAL+B5b6LFX1TmEwbDvikhplIDUu5swAHhyYlKgqjMJrSfnRbEuro8jSni+CVxAGPfyEHCVqv41ml9GOMvnF8AG4ELgga0eoM3dC3QF1kUx28U0DADDVq3jpBmfcueTr3HBm+9TVFG39YWMMWYzmTVoxXnfcWcGJJy6PERVl3bQNkcAnwMjVLVxd1RnY6eBpIG7d32OAz5dCEBFXg7vjRzEjz/5TnKDMsa0h3bLItzVlZt93vvrCtI6Y8noCy6ISA6hG+ppS1RMuljdpwezhw+ksLqGVT2LKelmd102xrRSWqcmX5axyYqE04neINwe4Ngkh2NMi/XeUMaqPl+c+VNY2dzZ+cYY0zl0aLKiqgvpoHxPVZUwJsSYtNK1vIINed3AObLqYvQs2baLwRljTKbI2JYVY9JVUXkFLgaxnGwKKyr5tG/vZIdkjDFJ1aZnAxljtt9zOw+hsKKGfms3siG/gKtnNL7kjzHGbEVmnQxkyYoxqeaBNw6ny33diD/Umx/OPwGXZf+mxpjOzbqBjDHGmEyTYReLtJ9sxhhjjElplqwYk4KmT5/O9OnTufzyy5MdijHGJJ0lK8akmMYJiiUsxphWswG2xhhjjDEdxwbYGmOMMRknA5pTEljLijFpwLqCjDGdmbWsGGOMMZkmsxpW0qtlRUQ2icj+yY7DGGOMMR2nTVtWRGQasD9QC8SABcCNqvpEW6xfVYvaYj3GGGOMSR/t0bJyfZRU9AamAI+KyKh22I4xxhhjOoF2G7OiqnUicg9wO7AXMFdEvgNcBewIrABuUNVH6pcRkbOAK4C+wLOEXrc6VZ0QzffAwar6VvR8PHA1MBxYCExS1aejeROAXwJ3AJcCXYG/Aj9W1ZiIDCe0/JwB/C8wBPgPcKaqrojWcSFwHjAYKAEeAX6pqrGEeH4CTAB2BWYC3we+B1wEFAJ3qeqVCfu4O/AbYBxQGa3zalWt3bYjbTqLyy+/nBNOOIF99tkn2aEYY1KdjVlpGRHJI3zRA8wRkSOA+4CfAb2AM4E/iMghUf1DgD8A50TzXyR88Te3/gMIX/SXE1pxrgAeE5F9E6oNA/oTkqO9CUnESY1WdSJwCCEh6QpclzBvKXA00A34NjAROLvR8qcB3yEkWFXAP4Ge0TYPBy4WkQOjmPsBbwBPRdvbHziCkCwZs9Wzfp566inefffdDorGGGNSQ3skK1eKSCmh1eAG4GxV/RC4EPidqr6pqnFVfRd4mNCyQfT3CVX9p6rWqepjwDtb2M4E4ElVfSmq/3fgaUJCUa+S0GpRrapzgX8A0mg916rqWlXdCDyaOF9Vn1TVBarqVXUG8BDw9UbL/0ZVl6pqBfA3YAChhadGVWcSWlvq13kGMFNV747mLwNuSjgG7aqsrMzKKV5uiQ8++CDpcVrZylbe/rJpufboBrpRVW8QkZ6ElpSvRX9HAF8TkYsS6mYDb0blwYA2WteiLWxnCPBeo2nzCN0r9VbXd9lEyoHiRsusaG6+iJxM6M4ZSThWecDbW1i+ItpmvNG0+nWOAA6Mkrl6jnAc2l1xcbGVU7zcEnvttVfS47Syla28/eV2lWF3XW7PMSslInI2ME9Evk1IPKao6m3NLLKM0G2TaCgwv5n6SwhjVRKNjKZvNxEZQmj5OQF4SVVrROTXfLllpjUWAVNV9Zi2iNFknptvvnmLXUE2ZsUY0xm160XhVHW9iPwW+BXwc2CKiLwN/JvQmjAWcKqqhC6Wl0TkfuBfwHeB/Wg+WXkAmCoiDwFTgSMJicVhbRR+EaGbbA1QKyL7AacDn2zHOh8EfiEiEwldTjWEhGu0qr68feGaTHfzzTcnOwRjTLrIrIaVDrko3O+AgcAgwuDZ24C1hO6T2wlJAar6BmFcy2TCmTfHAs8A1U2tVFWnEwbp/jqqfytwmqo27qbZJqr6CXAN4aykUsJA3se2c50rCd1i3yGcvVRCGGczcnvWa4wxxmQy571PdgzNEpH/AM+r6q+SHUuGSN0X2zRorhvIWlaMyTjt1v7hflWz2ee9vyIvrdtaUureQCLyXeBlQvfIBML4kA45U8YYY4wxqSmlkhVgPHAvYTzLXOB4Vf08uSEZY4wxaSat21G+LKWSFVU9OdkxGJOKrAvIGNOZpVSyYowxxpi2kFlNKx1xNpAxxhhjzDazZMWYFNO4y8e6gIwxreYaPdKcdQMZk4IOPPBAAI477rgkR2KMMclnLSvGGGOMSWnWsmKMMcZkmgzo+klkLSvGGGOMSWmWrBhjjDEmpVmyYowxxpiUZmNWjDHGmExjY1aMMcYYYzqOJSvGGGOMSWmWrBhjjDGdjHNuoXNu92TH0VI2ZsUYY4zJNC6zBq1Yy4oxxhiTabbh3kDOuTOcc7Occx865552zvWLpv/HObd3VL7TOfdxVM5xzq11znVtl31IYMmKMcYY08lFXUI3A0d67/cAPgJ+H83+B/D1qHwQUOmcGwjsDXzivS9v7/isG6gTcc69AvRJdhwAOTk5ferq6tYmO45UZsdo6+wYtYwdp61L0jF62Xt/VHus2F+c09p+oK8BL3rvV0TP7wZmRuV/AFc65x4B1gFvEJKXEcA/2yDcrbJkpRNpr3+KbSEiqqqS7DhSmR2jrbNj1DJ2nLbOjtEW/RsYBxxDSFzeACYSkpWrOyIA6wYyxhhjzOvAN51zA6Ln5wCvAXjvq4H3gcuBqcDbwIHAHlG53VnLijHGGNM5TXXO1SU8/1/gNeecB+YDP0qY9w/CGJX/eu9jzrm5wALvfU1HBGrJikmWPyc7gDRgx2jr7Bi1jB2nretUx8h7P7yZWQ80U/8m4KaE599sh7Ca5bz3Hbk9Y4wxxphWsTErxhhjjElp1g1kOoSIFAL3A18F6oCLVfWFJuodBrwIzIkmVavqvh0VZ0cTkdGEZtfehFMCz1DVzxvVyQbuAI4CPHCzqt7b0bEmUwuP0yTgx8DyaNJ0VT2/I+NMFhH5NTAeGA6MVdWPmqjTqd9HLTxGk+ik76FUZ8mK6SgXAxtVdZSI7AS8KSKjVHVTTqU1hAAADNxJREFUE3Vnd6JTCO8C/qiqD4vIaYRrGxzeqM6pwChgJ8KX9QwRmaqqCzs00uRqyXECeFBVL+7Y0FLCM8DvgDe3UKezv49acoyg876HUpp1A5mOciLhC4boF7ECRyc1oiQTkX6Eaxc8Fk16DBgnIn0bVT0RuEdV46q6hvCh+72OizS5WnGcOi1VfUtVl2ylWqd+H7XwGJkUZcmK6ShDgUUJzxcDQ5qpO1pE3heRd0TkzPYPLWmGAMtUNQYQ/V3Ol49La45dJmrpcQI4SUQ+FJFXRWT/jgwyDXT291FL2XsoBVk3kGkTIvI+4cOwKf1bsar3gSGqukFERgBTRWSZqk7d7iBNprsLuFFVa0XkCOBZEdlVVdclOzCTNuw9lKIsWTFtQlXHbWm+iCwGhgFroklDCVdMbLyejQnlBSLyDOFKiZmYrCwBBotItqrGogGQg6LpieqP3X+j541/IWe6Fh0nVV2ZUH5NRJYAuxMuDW7sfbRV9h5KXdYNZDrKE0RXQ4wG2O4NvNy4kogMFBEXlXsBRwIfdGCcHUZVVxP27eRo0snAjGg8QaIngHNEJCsap/Ed4G8dF2lytfQ4icjghPJehLM+PuugMNNBp34ftYS9h1KXtayYjnIbMEVE5gIx4IeqWgYgItcBy1X1LsKpheeJSC3h/fmAqj6brKA7wLnAAyJyNVACnAEgIi8CV6uqAg8B+wL1p+pep6oLkhFsErXkOP1KRL5KeH/VAKcn/lLOZCJyB3ACMIDQdbpOVXez99EXWniMOu17KNXZFWyNMcYYk9KsG8gYY4wxKc2SFWOMMcakNEtWjDHGGJPSLFkxxhhjTEqzs4GMMcaYVhCRycCxwGpV3b0F9b8PTCLcQHKmqp7SvhFmHmtZMSbFOeeGO+e8c26Hdt7Ouc65hxKev+Scu7Q9t2ma5pyb65yb0MK6HfL+6AjOuS7Rvu+S7Fi2Ygrh7tVbFV1X6n+BA1V1N+Bn7RhXxrJkxWQM59xI59wTzrmVzrlNzrklzrmnnXN50fwJzrm5TSzX3PRToy+Ba5qYN805Vx1tZ4NzboZzbnz77Fn7c851Ba4j/PoDwHt/tPf+1qQFtRXRa3NQsuPoDNrjWDvnDnPO1SVO895XE67JdFtbbqutqeq/gPWJ00RkRxF5WUTeE5E3RaQ+4TqHcMfwkmjZ1R0cbkawZMVkkheBFcDOQDGwP/AK4LZxfT8ifCCd5ZzLbmL+9d77IqA34U7AjzvnRm/jtpLtNGCW935esgMxnd5jwOHOuVHJDqSV/gz8RFW/ClwM3BlNH024Oet0EXlbRFrUImM2Z8mKyQjOud6EJOUu7/0GHyz13t8V/Vpr7fp2BQ4GzgQGAkc3V9d7X0f4YMoGxjaxrvOdcx80mjbCORdzzg2Pnt8ftQSVOedmO+ea7dN2zk1yzk1tNG2ac+6XCc93d8694pxb45xb7Jy7yTmXu4Vd/g7wWnPrTOhqODOKr9w596Jzrqdz7mbn3OqoRev8hOUnRE36lznnVkR1fpMYx9b22zm3h3Pu5Wg/1tfvt3NuZlTl1ah1695mjlWhc+530TbWOueecc4NTZg/LYrpySiGec65bzd3kBL26efOuaXRMr92zvWO1rHROfdpYiuEcy7HOXe1c26+c67EOfcP59zuCfNznXO/TTiGlzWx3YOdc29Fx2Cec+4XzrkWJ+HOufHOuZlRK+BM59zxjfepUf0p9ce0uWPtnFsY7ddb0XR1zu3d1DoSpi10zp3mnBsEvARkR8tucs6dCeC930i4f9G3Wrp/ySYiRcABwBMi8gFwN+FzA8LY0J2Awwi3irhHRHokI850ZsmKyQje+3XAx8C9zrkznHNjWvNh3oQfAh96718gtNj8qLmKLnQznQ/UAjObqPIosItzbq+EaROAad77hdHzt4C9gB6E7pgpzrkx2xK4c64f4cZrTwGDCS1MRxD6zZszDpjdgtWPBw4i3ARvOPAOMI9wY8EfAP+XmAwQbpw3FBgZxXEccEnC/Gb32zk3MNqPN6JtDQBuBvDe7xktf6T3vsh7f3Yz8d4O7Bc9hgFrgefd5i1lZwK/AboDfwAecM4VbuEYDIviHRkdi58QvnhvA3oSjvv9CfUvIdwe4JvRPrwJvOac6xbNv5wwWPMAYES0r8PqF46Ox4vR+vsCxwAXAKdvIcYGzrkDgEei7fQGrgAec87t25Llt3KszwUuBHoR7jP0YsJ+bWmdywk/AGLROou89w8kVJlFeE+miyygVFX3SnjsGs1bCjynqrXR7Q3mEJIX0wqWrJhMchgwjTCA7QNglXPuqkZJywjnXGnigy+aawFwzuUTvlzqv3DuA452Xx7AeGW0/FLg28B47/2Xxr5470uAZwlf5kTxnAlMTqhzn/d+nfc+5r3/C/BhtD/b4gxgpvf+bu99jfd+GXBTNL05PYGNW5hf73rv/fooOXwBqPXe3+O9r/Pev0S4b89XEurHgUu895VRF9OthEQN2Op+nw7M9d7f5L0vj/alxXffds5lEY7zL733y7z35YT3xq7APglVH/fe/9t7Hyc05Xdny18mlcC1UTwzCQnqf733b3vvY8DDwCjnXPeo/g+AW7z3n0atfNcR7j1zTDT/jGj+XO99JaELIfE+KD8GnvDePxsdp08JSdWWXs9EE4AnvfcvRa/T34GngYktXH5L7vPev+e9rwFuIRybY9tgvRsJCVBaiO4Wv0BEvgcgIk5E6pO8Z4je0yLSh9AtND8ZcaYzS1ZMxvDer/XeX+G9H0f45XspcDVRkhBZ4L3vkfggfBkk+h5QRPjSgfCrdg3Q+Nf7jdE6+nnvD/DeP7+F8O4HTom6QA6P4nsKwpeqc+4659xnUTN9KbAn4Vf0thgBHNgoIZtM+FXfnBJgq7+ICWOC6lU0el4/rTjh+WrvfUXC84XADtCi/R5O+BW6rfoCXYCGm/V57zcBq4EhCfVWJMwvj4qJ+9DY6iixqdf4ONTvb/06hjSKIU44DvUx7BA9T4whcRDmCODkRq/nNXzRzbA1m20/Mo/Nj8G2Wlhf8OFGc4uJXt/t1I1GA1hTiYg8BvwH2FlElorIWcCpwFkiMpPQylvfnfgKsE5EZgOvA5eo6rpkxJ3O7DorJiNFX5BTnHM/IXQztMYPCeNPPkpolOlBGGh7ffTrubVeA6oJ3SDHA3+JfkVD6Mc+GzgSmO29jzvnlOYHBpcBXRtNG5RQXgRM9d4fQ8vNAMYAz7VimZbo55wrTEhYhhNaomDr+70Q+O4W1r21u7CuIRzz4cBcAOdcEdAPWNKqvdg+S6IYiGLIip7Xx7Cs0fyubJ6oLgIme+/PZ9tstv3IyITtN/d+WpzwvLlj3bDeqMVwKF+8vmVAn4T5OYRjXy8x4Wtsd0LLXUpS1ZObmfWlwbOq6oGLoofZRtayYjKCCwM9b3JhYGluNKhxPOFD781WrGcMYRzC8YQkp/6xD6Fl4pvbEl+U4DwI/JRwm/rJCbO7AXWEL9cs59xEQgtDc94Dxjnnvhrt5wWEX9/1HgTEOTfROZcftWCMdM5t6SyEZ4BvtH7PtioLuMU5V+CcG0no4qgfm7C1/X4Y2NmFAbqFzrk851xijCvZQndN1ILxIHC9c25QNA7lN8CnwLtttH8tMQW41Dk3OhrfdCXhh+Lfo/kPAZc453Z0zhUQusoSP5vvBE5yzh2X8N4e45w7tIXbfwAY75z7H+dctnPuaMJ7sL6b8wNCUnls9F45Hjik0TqaO9YTnXPjohbDS4DChP16D/i6C4PJuwA3AomDvFcSBtgmvndxzhUT/t/aOnE2acySFZMpagi/2p4iNB+vAX4J/NR7/0Qr1vMj4H3v/fPe+5UJjw+BJ9jCQNsWuB84lNAVlfhl+QBhoOpcwq/sMWwhwfLeTwN+C7xM6H7oD0xPmL8S+BrhDJ+FhC6epwm/ppvzELBnlFC0pUWEX9oLCPv4MuHLGLay39EgzMMIg4OXEr7cEgfnXglc58IZNnc3s/2fA0o4u2QxoevkW9vYOratbiOcjvsqsIrQDXhkdNYLhPFErwBvE47TYsJxA8B7/xFhHMjPCK/3akIC1KJuQu/9dMLYnV8T3gu3Aqd579+O5s8jDJL9M+F/5yjgyUarae5Y/xm4I1rvicAx3vsN0bxHCAnH+4Rup8WE17k+rjnAn4B3o+6t+gHDJwOve+8/b8n+mc7BhW5GY0xn55w7FzjQe9+is0xasL4JhMGt6Xa9DNMCzrmFhNf34a3VbcU6uwAfERLKT9pqvSb92ZgVYwwA3vu7gLuSHYfpvKKzpey0XvMl1g1kjDHGmJRm3UDGGGOMSWnWsmKMMcaYlGbJijHGGGNSmiUrxhhjjElplqwYY4wxJqVZsmKMMcaYlGbJijHGGGNS2v8DStjnxDEdMvoAAAAASUVORK5CYII=\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "## CatBoost" ], "metadata": { "id": "tMrt7a0u-wAG" } }, { "cell_type": "markdown", "source": [ "In this section, we would explore some base cases of using catboost, such as model training, cross-validation and predicting" ], "metadata": { "id": "UpYxeNoyM7S9" } }, { "cell_type": "markdown", "source": [ "### Classification task" ], "metadata": { "id": "-LL0QrhgM_i0" } }, { "cell_type": "code", "source": [ "iris = datasets.load_iris()\n", "df = pd.DataFrame(data= np.c_[iris['data'], iris['target']],columns= iris['feature_names'] + ['target'])\n", "X_train, X_test, y_train, y_test = train_test_split(iris['data'], iris['target'], random_state=42)" ], "metadata": { "id": "a1UBXodT9yvW" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "clf = CatBoostClassifier(boosting_type='Plain', learning_rate=0.1, n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent')\n", "clf.fit(X_train, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "PojeH09ENdbi", "outputId": "181716a5-6e96-4907-fd27-adb98f7e1b36" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 30 } ] }, { "cell_type": "code", "source": [ "clf.fit(X_train, y_train)\n", "y_pred = clf.predict(X_test)\n", "score = accuracy_score(y_pred, y_test)\n", "print('Score: ' + str(score))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "yM5MyOi1P9Fd", "outputId": "6a64a378-6ea1-4e93-e784-2e18131690c4" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Score: 1.0\n" ] } ] }, { "cell_type": "code", "source": [ "clf.get_all_params()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "B1jqoOOXOpVL", "outputId": "67ad9981-1813-4dbf-9410-2b64f0bdd01c" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'auto_class_weights': 'None',\n", " 'bagging_temperature': 1,\n", " 'bayesian_matrix_reg': 0.10000000149011612,\n", " 'best_model_min_trees': 1,\n", " 'boost_from_average': False,\n", " 'boosting_type': 'Plain',\n", " 'bootstrap_type': 'Bayesian',\n", " 'border_count': 254,\n", " 'class_names': [0, 1, 2],\n", " 'classes_count': 0,\n", " 'depth': 6,\n", " 'eval_metric': 'MultiClass',\n", " 'feature_border_type': 'GreedyLogSum',\n", " 'force_unit_auto_pair_weights': False,\n", " 'grow_policy': 'SymmetricTree',\n", " 'iterations': 100,\n", " 'l2_leaf_reg': 3,\n", " 'leaf_estimation_backtracking': 'AnyImprovement',\n", " 'leaf_estimation_iterations': 1,\n", " 'leaf_estimation_method': 'Newton',\n", " 'learning_rate': 0.10000000149011612,\n", " 'loss_function': 'MultiClass',\n", " 'max_leaves': 64,\n", " 'min_data_in_leaf': 1,\n", " 'model_shrink_mode': 'Constant',\n", " 'model_shrink_rate': 0,\n", " 'model_size_reg': 0.5,\n", " 'nan_mode': 'Min',\n", " 'penalties_coefficient': 1,\n", " 'pool_metainfo_options': {'tags': {}},\n", " 'posterior_sampling': False,\n", " 'random_seed': 42,\n", " 'random_strength': 1,\n", " 'rsm': 1,\n", " 'sampling_frequency': 'PerTree',\n", " 'score_function': 'Cosine',\n", " 'sparse_features_conflict_fraction': 0,\n", " 'task_type': 'CPU',\n", " 'use_best_model': False}" ] }, "metadata": {}, "execution_count": 32 } ] }, { "cell_type": "markdown", "source": [ "### Regression" ], "metadata": { "id": "Gm_vj7HGQYn1" } }, { "cell_type": "code", "source": [ "X,y = datasets.load_diabetes(return_X_y=True)\n", "\n", "catb = CatBoostRegressor(boosting_type='Plain', learning_rate=0.1, random_state=42, n_estimators=100, thread_count=-1, logging_level = 'Silent')\n", "\n", "scores = cross_val_score(catb, X, y, scoring='neg_mean_squared_error', cv=5)\n", "\n", "# Take square root of the scores\n", "rmse = np.sqrt(-scores)\n", "\n", "# Display accuracy\n", "print('RMSE:', np.round(rmse, 3))\n", "\n", "# Display mean score\n", "print('RMSE mean: %0.3f' % (rmse.mean()))" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "n0pWxCpTPS1I", "outputId": "2af613d0-0a89-49e1-ef39-24156a9e18f9" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "RMSE: [54.744 56.125 59.595 56.908 56.583]\n", "RMSE mean: 56.791\n" ] } ] }, { "cell_type": "code", "source": [ "catb.fit(X,y)\n", "catb.get_all_params()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "RtQ7lRh9Q9v1", "outputId": "29888ec1-eb04-48b3-840e-b875f7f2cc38" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'auto_class_weights': 'None',\n", " 'bayesian_matrix_reg': 0.10000000149011612,\n", " 'best_model_min_trees': 1,\n", " 'boost_from_average': True,\n", " 'boosting_type': 'Plain',\n", " 'bootstrap_type': 'MVS',\n", " 'border_count': 254,\n", " 'classes_count': 0,\n", " 'depth': 6,\n", " 'eval_metric': 'RMSE',\n", " 'feature_border_type': 'GreedyLogSum',\n", " 'force_unit_auto_pair_weights': False,\n", " 'grow_policy': 'SymmetricTree',\n", " 'iterations': 100,\n", " 'l2_leaf_reg': 3,\n", " 'leaf_estimation_backtracking': 'AnyImprovement',\n", " 'leaf_estimation_iterations': 1,\n", " 'leaf_estimation_method': 'Newton',\n", " 'learning_rate': 0.10000000149011612,\n", " 'loss_function': 'RMSE',\n", " 'max_leaves': 64,\n", " 'min_data_in_leaf': 1,\n", " 'model_shrink_mode': 'Constant',\n", " 'model_shrink_rate': 0,\n", " 'model_size_reg': 0.5,\n", " 'nan_mode': 'Min',\n", " 'penalties_coefficient': 1,\n", " 'pool_metainfo_options': {'tags': {}},\n", " 'posterior_sampling': False,\n", " 'random_seed': 0,\n", " 'random_strength': 1,\n", " 'rsm': 1,\n", " 'sampling_frequency': 'PerTree',\n", " 'score_function': 'Cosine',\n", " 'sparse_features_conflict_fraction': 0,\n", " 'subsample': 0.800000011920929,\n", " 'task_type': 'CPU',\n", " 'use_best_model': False}" ] }, "metadata": {}, "execution_count": 47 } ] }, { "cell_type": "markdown", "source": [ "### Speed" ], "metadata": { "id": "tIPXVGF0RlOn" } }, { "cell_type": "code", "source": [ "df = pd.read_csv('exoplanets.csv')\n", "# Split data into X and y\n", "X = df.iloc[:,1:]\n", "y = df.iloc[:,0]\n", "\n", "# Split data into train and test sets\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=2)" ], "metadata": { "id": "wInbb9ASREGF" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "start = time.time()\n", "\n", "# Instantiate the XGBRegressor, xg_reg\n", "ca_reg = CatBoostClassifier(n_estimators=100, max_depth=2, random_state=42, logging_level = 'Silent')\n", "\n", "# Fit xg_reg to training set\n", "ca_reg.fit(X_train, y_train)\n", "\n", "# Predict labels of test set, y_pred\n", "y_pred = ca_reg.predict(X_test)\n", "\n", "score = accuracy_score(y_pred, y_test)\n", "\n", "print('Score: ' + str(score))\n", "\n", "end = time.time()\n", "elapsed = end - start\n", "\n", "print('Run Time: ' + str(elapsed) + ' seconds')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "sUqahaIQRrvQ", "outputId": "01bc5fa3-967b-429e-dee9-d217ab87aaaa" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Score: 0.9913522012578616\n", "Run Time: 15.904590129852295 seconds\n" ] } ] }, { "cell_type": "markdown", "source": [ "### Hyperparameter" ], "metadata": { "id": "ELzRE-rLSEgm" } }, { "cell_type": "markdown", "source": [ "You can check more details at https://catboost.ai/en/docs/references/training-parameters/. There are also tutorials about hyperparameter tuning https://github.com/catboost/tutorials/blob/master/hyperparameters_tuning/hyperparameters_tuning_using_optuna_and_hyperopt.ipynb" ], "metadata": { "id": "QPfUwGMySJW-" } }, { "cell_type": "markdown", "source": [ "### For categorical variable and missing value" ], "metadata": { "id": "Eh9WywLIS2L2" } }, { "cell_type": "markdown", "source": [ "One of the differences between CatBoost and other gradient boosting libraries is its advanced processing of the categorical features (in fact \"Cat\" in the package name stands for \"CATegorical\").\n", "\n", "CatBoost deals with the categorical data quite well out-of-the-box. However, it also has a huge number of training parameters, which provide fine control over the categorical features preprocessing." ], "metadata": { "id": "2ms2jQBMS7Pm" } }, { "cell_type": "markdown", "source": [ "The amount of parameters related to categorical features processing in CatBoost is overwhelming. Here is a hopefully the full list:\n", "\n", "* `one_hot_max_size` (int) - use one-hot encoding for all categorical features with a number of different values less than or equal to the given parameter value. No complex encoding is performed for such features. \n", "\n", "* `model_size_reg` (float from 0 to inf) - The model size regularization coefficient. The larger the value, the smaller the model size. This regularization is needed only for models with categorical features (other models are small). Models with categorical features might weight tens of gigabytes or more if categorical features have a lot of values. If the value of the regularizer differs from zero, then the usage of categorical features or feature combinations with a lot of values has a penalty, so fewer of them are used in the resulting model. Default value is 0.5\n", "\n", "* `max_ctr_complexity` - The maximum number of features that can be combined. Each resulting combination consists of one or more categorical features and can optionally contain binary features in the following form: “numeric feature > value”. For regression task on CPU the default value is 4.\n", "\n", "* `has_time (bool)` - if true, the 1-st step of categorical features processing, permutation, is not performed. Useful when the objects in your dataset are ordered by time. For our dataset, we don't need it. Default value is False\n", "\n", "* `simple_ctr` - Quantization settings for simple categorical features.\n", "combinations_ctr - Quantization settings for combinations of categorical features.\n", "\n", "* `per_feature_ctr` - Per-feature quantization settings for categorical features.\n", "\n", "* `counter_calc_method` determines whether to use validation dataset (provided through parameter eval_set of fit method) to estimate categories frequencies with Counter. By default, it is Full and the objects from validation dataset are used; Pass SkipTest value to ignore the objects from the validation set\n", "ctr_target_border_count - The maximum number of borders to use in target quantization for categorical features that need it. Default for regression task is 1.\n", "\n", "* `ctr_leaf_count_limit` - The maximum number of leaves with categorical features. Default value is None i.e. no limit.\n", "\n", "* `store_all_simple_ctr`- If the previous parameter ctr_leaf_count_limit at some point gradient boosting tree can no longer make splits by categorical features. With Default value False the limitation applies both to original categorical features and the features, that CatBoost creates by combining different features. If this parameter is set to True only the number of splits made on combination features is limited.\n", "\n", "The three parameters `simple_ctr`, `combinations_ctr`, and `per_feature_ctr` are complex parameters that control the second and the third steps of categorical features processing." ], "metadata": { "id": "o6zMME3hZvbw" } }, { "cell_type": "code", "source": [ "# Select target\n", "data = pd.read_csv('melb_data.csv')\n", "y = data.Price\n", "\n", "# To keep things simple, we'll split the columns into numerical can categorical features\n", "melb_predictors = data.drop(['Price', 'Date', 'Address'], axis=1)\n", "cat_col = melb_predictors.select_dtypes(exclude=['int64','float64'])\n", "\n", "# Divide data into training and validation subsets\n", "X, X_v, y_train, y_valid = train_test_split(melb_predictors, y, train_size=0.8, test_size=0.2, random_state=0)\n", "X_train = X.select_dtypes(exclude=['object'])\n", "X_valid = X_v.select_dtypes(exclude=['object'])\n", "X_train_cat = X.select_dtypes(exclude=['int64','float64'])\n", "X_valid_cat = X_v.select_dtypes(exclude=['int64','float64'])" ], "metadata": { "id": "RjqW39jGSEAG" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "categorical_features_names = list(X_train_cat.columns)\n", "\n", "for col in categorical_features_names:\n", " X[col] = X.loc[:,col].fillna(value='nan')\n", " X_v[col] = X_v.loc[:,col].fillna(value='nan')\n", " X[col] = X[col].astype('category')\n", " X_v[col] = X_v[col].astype('category')" ], "metadata": { "id": "WJHEOWfJUTf4" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names)\n", "catbr.fit(X, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "wlDd6-DsR2_4", "outputId": "c3ed784d-3c64-45e0-f238-ce87e6dd38eb" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 170 } ] }, { "cell_type": "code", "source": [ "preds = catbr.predict(X_v)" ], "metadata": { "id": "U0d4xfjRVhy6" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "-x8Pex8GVjZT", "outputId": "0d1494ea-bb33-4049-e9d4-a3a2ff071259" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "164721.46472522244" ] }, "metadata": {}, "execution_count": 111 } ] }, { "cell_type": "markdown", "source": [ "The first thing we try is to make CatBoost use one-hot encoding for all our categorical features. The documentation says, that for the features for which one-hot encoding is used no other encodings are computed." ], "metadata": { "id": "jBmQWDoLYI6g" } }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, one_hot_max_size=500)\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "4Zh03QOFXndQ", "outputId": "09002728-77a8-4cbf-a533-a113efa028b4" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "163165.1377008556" ] }, "metadata": {}, "execution_count": 112 } ] }, { "cell_type": "markdown", "source": [ "Let us try to set model size regularization coefficient to 0 - thus we allow our model to use as many categorical features and its combinations as it wants." ], "metadata": { "id": "N9S8KIKCa_ev" } }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, model_size_reg=0)\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "zF2EsTaUZct7", "outputId": "546c2025-155a-443b-c088-6b673e173312" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "165007.46639148306" ] }, "metadata": {}, "execution_count": 113 } ] }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, model_size_reg=1)\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Evt8PjPXav1V", "outputId": "8110d5ee-b0a3-4ae8-aa13-050e6c13bc36" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "160827.54657606702" ] }, "metadata": {}, "execution_count": 114 } ] }, { "cell_type": "markdown", "source": [ "Note that any combination of several categorical features could be considered as a new one. Although it is not mentioned in the documentation, this parameter value has to be smaller than 15." ], "metadata": { "id": "gMYfIC-XbIkr" } }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, max_ctr_complexity=6)\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Hn4vYk5Ja4vv", "outputId": "d9780de7-cc42-4787-d583-b32e0d44b403" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "163529.3517553931" ] }, "metadata": {}, "execution_count": 115 } ] }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, max_ctr_complexity=0)\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "gDpLpL_ybXjn", "outputId": "b7a59525-0e3b-4b91-a912-411187943ba7" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "164721.46472522244" ] }, "metadata": {}, "execution_count": 116 } ] }, { "cell_type": "markdown", "source": [ "Counter method is very similar to the traditional Frequency Encoding" ], "metadata": { "id": "ygXiBf7Hcdpg" } }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, simple_ctr='Counter', combinations_ctr='Counter')\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Wq3m4Bo4bv9F", "outputId": "8c667b12-5b9b-4f0a-8ea0-7bdb330842ce" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "164993.47954656056" ] }, "metadata": {}, "execution_count": 118 } ] }, { "cell_type": "markdown", "source": [ "Now we proceed to the settings of the encodings methods that require target quantization. The first choice is `Borders` vs. Buckets" ], "metadata": { "id": "5O4sYVCFcztY" } }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, simple_ctr='Borders', combinations_ctr='Borders')\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "HiUGNJBzcj4T", "outputId": "02ce18b2-9d1d-4e8b-aa41-f9a4c3db0133" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "166920.94141120723" ] }, "metadata": {}, "execution_count": 119 } ] }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, simple_ctr='Buckets', combinations_ctr='Buckets')\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "fKZCjPIcc8pe", "outputId": "888d596e-0853-422c-a75d-86273c49ae25" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "168168.9386958123" ] }, "metadata": {}, "execution_count": 120 } ] }, { "cell_type": "markdown", "source": [ "It is quite common to use several encodings for a categorical feature. For instance, CatBoost creates 4 different encodings for each categorical feature by default. By default, CatBoost uses several encoding techniques to encode each categorical feature.\n", "\n", "* First it uses `Borders` method with one target border `TargetBorderCount=1` (in our example for each categorical feature we just want to see if it makes the car more expensive). The obtained float encodings are further discretized into `CtrBorderCount=15` different values. Three values of Prior parameter are used to create 3 three different encodings: `Prior=0/1:Prior=0.5/1:Prior=1/1`\n", "\n", "* Also for each categorical feature, we create an encoding with Counter method. The number of categorical encoding value borders `CtrBorderCount` is also equal to 15, and only one value of `Prior=0/1` is used." ], "metadata": { "id": "Rt8jFH_IdNL3" } }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names, ctr_target_border_count=10)\n", "catbr.fit(X, y_train)\n", "preds = catbr.predict(X_v)\n", "mean_absolute_error(y_valid, preds)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1T-Q0uVTc_7G", "outputId": "a066252c-eb26-43fc-f125-6bb7b2bcd943" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "166281.68070428775" ] }, "metadata": {}, "execution_count": 171 } ] }, { "cell_type": "code", "source": [ "catbr = CatBoostRegressor(n_estimators=100, random_state=42, thread_count=-1, logging_level = 'Silent', cat_features=categorical_features_names)\n", "catbr.fit(X, y_train)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "SHRj34ZEdxzw", "outputId": "a1c40924-bb0e-4fc1-c580-a8d26afa60ee" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 172 } ] }, { "cell_type": "markdown", "source": [ "### SHAP values" ], "metadata": { "id": "JbvYB_SrkHqJ" } }, { "cell_type": "code", "source": [ "explainer = shap.Explainer(catbr)\n", "shap_values = explainer(X)" ], "metadata": { "id": "NNOn6R-dfQ5G" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "shap.summary_plot(shap_values, X)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 542 }, "id": "HymD7ehvfYav", "outputId": "4308601c-da6f-444a-e77e-b445ee2ba06e" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "code", "source": [ "" ], "metadata": { "id": "hZX-5gX4f8o2" }, "execution_count": null, "outputs": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.10" }, "nav_menu": {}, "toc": { "navigate_menu": true, "number_sections": true, "sideBar": true, "threshold": 6, "toc_cell": false, "toc_section_display": "block", "toc_window_display": false }, "colab": { "name": "14_ensemble.ipynb", "provenance": [], "collapsed_sections": [], "toc_visible": true } }, "nbformat": 4, "nbformat_minor": 0 }